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();
}
}
}
}
}
