Android編程：雙工udp客戶端
本文博客鏈接:http://blog.csdn.net/jdh99,作者:jdh,轉載請註明.
環境：
主機:WIN10
開發環境:Android Studio 2.2 Preview 3
說明：
在<<Android編程：UDP客戶端和TCP客戶端>>介紹了編寫UDP客戶端方法，在此客戶端中發送的每一個數據包都會產生一個線程。這麼做是因爲發送函數send一般在UI線程中被調用，而發送線程是一個單獨的線程，這樣就存在線程同步的問題。現在編寫新的程序，單獨用一個線程進行發送，並增加線程同步機制。
新客戶端具有以下功能：
- 雙工通信。發送一個線程，接收一個線程，不佔用UI主線程
- 發送線程在發送完成後會自鎖。當有新的任務需要發送，再喚醒發送線程。
發送線程同步機制：
增加 一個緩存區sendListCache負責存儲當前需要發送的數據。發送線程中需要發送的數據都放在sendList列表中。
則發送一幀分爲3個步驟：
- 將需要發送的數據放入sendListCache
- 將sendListCache中的數據同步到sendList中，並清空sendListCache
- 發送sendList中的數據
3個步驟中耗時的步驟爲第3步，而1，2兩步均爲內存中數據拷貝。所以用讀寫鎖對1，2兩步進行加鎖操作。
源碼：
UdpClinet.java
package com.bazhangkeji.classroom.net;
import android.util.Log;
import com.bazhangkeji.classroom.Config;
import com.bazhangkeji.classroom.common.Crc16;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.util.ArrayList;
import java.util.List;
import java.util.Observable;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
public class UdpClient extends Observable implements Config, Protocol, Runnable {
private final String TAG_LOG = "UdpClient";
private static final int MAX_FRAME_LENGTH = 2048;
private DatagramSocket udpSocket;
private int frameIndex = 0;
private static UdpClient udpClient;
private List<NetSendParameter> sendListCache;
private List<NetSendParameter> sendList;
private ReadWriteLock sendListCacheLock;
// 線程鎖:當前發送線程全部發送完成後就自鎖等待
private static final Class lockSendThread = UdpClient.class;
public static UdpClient getInstance() {
if (udpClient == null) {
udpClient = new UdpClient();
new Thread(UdpClient.getInstance()).start();
}
return udpClient;
}
private UdpClient()
{
newSocket();
sendListCache = new ArrayList<>();
sendList = new ArrayList<>();
sendListCacheLock = new ReentrantReadWriteLock();
SendThread sendThread = new SendThread();
sendThread.init();
new Thread(sendThread).start();
}
private void newSocket() {
try {
udpSocket = new DatagramSocket(LOCAL_PORT);
}
catch (Exception e) {
e.printStackTrace();
}
}
/**
* 發送
* @param netSendParameter 發送參數
*/
public void send(NetSendParameter netSendParameter) {
sendListCacheLock.writeLock().lock();
sendListCache.add(netSendParameter);
sendListCacheLock.writeLock().unlock();
unlockSendThread();
}
private void unlockSendThread() {
synchronized (lockSendThread) {
lockSendThread.notifyAll();
}
}
private void testPrint(String tag, byte[] data, int length) {
StringBuffer buffer = new StringBuffer();
for (int i = 0; i < length; i++) {
buffer.append(String.format("%02x ", data[i]));
}
Log.i(TAG_LOG, tag + buffer.toString());
}
/**
* 發送幀序號增加
*/
private void frameIndexAdd() {
if (frameIndex == 0xffff) {
frameIndex = 0;
} else {
frameIndex++;
}
}
/**
* 讀取當前發送幀序號
* @return 幀序號
*/
public int readFrameIndex() {
return frameIndex;
}
@Override
public void run() {
byte[] bufferReceive = new byte[MAX_FRAME_LENGTH];
DatagramPacket receiveFrame = new DatagramPacket(bufferReceive, MAX_FRAME_LENGTH);
while (true) {
try {
udpSocket.receive(receiveFrame);
if (filter(receiveFrame)) {
setChanged();
notifyObservers(receiveFrame);
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
private boolean filter(DatagramPacket receiveFrame) {
if (!isSocketAddressValid(receiveFrame)) {
return false;
}
if (receiveFrame.getLength() < LEN_FRAME_HEAD) {
Log.i(TAG_LOG, "不滿足最小幀長");
return false;
}
int lenBody = ((receiveFrame.getData()[FRAME_BODY_LENGTH_POSITION] << 8) & 0xff00) + (receiveFrame.getData()[FRAME_BODY_LENGTH_POSITION + 1] & 0xff);
if (lenBody + LEN_FRAME_HEAD != receiveFrame.getLength()) {
Log.i(TAG_LOG, "正文長度不正確" + (lenBody + LEN_FRAME_HEAD) + " " + receiveFrame.getLength());
return false;
}
int frameHead = ((receiveFrame.getData()[FRAME_HEAD_POSITION] << 8) & 0xff00) + (receiveFrame.getData()[FRAME_HEAD_POSITION + 1] & 0xff);
if (frameHead != FRAME_HEAD) {
Log.i(TAG_LOG, "幀頭不正確");
return false;
}
int crcGet = ((receiveFrame.getData()[FRAME_CRC_POSITION] << 8) & 0xff00) + (receiveFrame.getData()[FRAME_CRC_POSITION + 1] & 0xff);
int crcCalc = Crc16.calc(receiveFrame.getData(), LEN_FRAME_HEAD, lenBody);
if (crcGet != crcCalc) {
Log.i(TAG_LOG, "crc不正確");
return false;
}
testPrint("接收:", receiveFrame.getData(), receiveFrame.getLength());
return true;
}
private boolean isSocketAddressValid(DatagramPacket receiveFrame) {
InetSocketAddress address = (InetSocketAddress) receiveFrame.getSocketAddress();
return (address.getHostName().equals(SERVER_IP) && (address.getPort() == SERVER_PORT));
}
private class SendThread implements Runnable {
private DatagramPacket sendPacket;
void init() {
byte[] Buffer_Send = new byte[MAX_FRAME_LENGTH];
sendPacket = new DatagramPacket(Buffer_Send, MAX_FRAME_LENGTH);
}
@Override
public void run() {
while (true) {
copyCache();
if (!sendList.isEmpty()) {
sendFrame();
sendList.clear();
}
checkThreadLock();
}
}
private void copyCache() {
sendListCacheLock.readLock().lock();
if (sendListCache.isEmpty()) {
sendListCacheLock.readLock().unlock();
} else {
for (NetSendParameter parameter : sendListCache) {
sendList.add(parameter);
}
sendListCacheLock.readLock().unlock();
sendListCacheLock.writeLock().lock();
sendListCache.clear();
sendListCacheLock.writeLock().unlock();
}
}
private void sendFrame() {
for (NetSendParameter parameter: sendList) {
send(parameter);
}
}
private void send(NetSendParameter netSendParameter) {
setPacketData(netSendParameter);
sendPacket.setPort(netSendParameter.port);
try {
sendPacket.setAddress(InetAddress.getByName(netSendParameter.ip));
} catch (IOException e) {
e.printStackTrace();
}
try {
udpSocket.send(sendPacket);
} catch (IOException e) {
e.printStackTrace();
}
testPrint("發送:", sendPacket.getData(), sendPacket.getLength());
}
private void setPacketData(NetSendParameter netSendParameter) {
byte[] arr = new byte[MAX_FRAME_LENGTH];
int j = 0;
arr[j++] = (byte)(FRAME_HEAD >> 8);
arr[j++] = (byte)FRAME_HEAD;
arr[j++] = (byte)PROTOCOL_VERSION_CODE;
arr[j++] = (byte)(netSendParameter.cmd >> 8);
arr[j++] = (byte)netSendParameter.cmd;
if (netSendParameter.frameIndex == 0) {
arr[j++] = (byte)(frameIndex >> 8);
arr[j++] = (byte)frameIndex;
frameIndexAdd();
} else {
arr[j++] = (byte) (netSendParameter.frameIndex >> 8);
arr[j++] = (byte) netSendParameter.frameIndex;
}
// 報文長度
arr[j++] = (byte)(netSendParameter.length >> 8);
arr[j++] = (byte)netSendParameter.length;
int crc = Crc16.calc(netSendParameter.frameBody, 0, netSendParameter.length);
arr[j++] = (byte)(crc >> 8);
arr[j++] = (byte)crc;
// 正文
for (int i = 0; i < netSendParameter.length; i++) {
arr[j++] = netSendParameter.frameBody[i];
}
sendPacket.setData(arr);
sendPacket.setLength(j);
}
private void checkThreadLock() {
synchronized (lockSendThread) {
try {
if (sendList.isEmpty()) {
lockSendThread.wait();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
