android中非堵塞socket通信
1、什么是同步与异步，堵塞与非堵塞
首先我们要明确搞明确：同步就等于堵塞？异步就等于非堵塞？这是不正确的，同步不等于阻 塞。而异步也不等于非堵塞。
1）那什么是同步编程?
2）那什么是异步编程？
当一个调用者异步发出一个功能调用时，调用者不能立马得到结果。
实际处理这个调用的部件在完毕后，通过状态、通知和回调来通知调用者。
以 android中AsyncTask类为例，顾名思义异步运行任务，在doInBackground 运行完毕后，onPostExecute 方法将被UI 线程调用，后台的计算结果将通过该方法传递到UI 线程，而且在界面上展示给用户.。在android或者java异步编程中须要注意下面几个知识点：回调，监听者模式，观察者模式。这几点在之后另外几篇文章中会提及。
3）什么是堵塞式编程？
由于这点定义跟同步编程的定义非常相像，所以非常多人觉得同步编程就等堵塞式编程。对于同步调用来说。非常多时候当前线程还是激活的，仅仅是从逻辑上当前函数没有返回而已。比如。我们在 socket编程中调用Receive函数，假设缓冲区中没有数据，这个函数就会一直等待，直到有数据才返回。而此时。当前线程还会继续处理各种各样的消
息。假设主窗体和调用函数在同一个线程中，除非你在特殊的界面操作函数中调用。事实上主界面还是应该能够刷新。可是在android中，因为主线程（UI线程）的不安全性。特别到4.0版本号后，系统已经不同意在主线程中进行耗时的同步编程。
所以android才出现了AsyncTask类用于异步编程。
4）什么是非堵塞式编程？
从这个定义上来说，非堵塞编程能够说是异步编程的一种，可是异步编程并不等于非堵塞式编程。
5）差别大概
那还有另外一方式。你能够叫一个人（监听者，观察者）帮你看着。直接你买票了，再通知你。你能够先去别的事情（而异步这不会这样。异步情况下是当一个进程发
起一个函数（任务）调用的时候。不会等函数返回）。堵塞是就是等排队，非堵塞就是直接走开。
2、几个关键知识点
1)java.net.InetSocketAddress
有效port值介于 0 和 65535 之间。port号 zero 同意系统在 bind 操作中挑选临时的port。
2)java.nio.channels.Selector
也可通过调用自己定义选择器提供者的 openSelector 方法来创建选择器。通过选择器的 close 方法关闭选择器之前，它一直保持打开状态。
打开一个选择器。
public abstract void close()throws IOException
关闭此选择器。
假设某个线程眼下正堵塞在此选择器的某个选择方法中，则中断该线程，如同调用该选择器的 wakeup 方法那样。
全部仍与此选择器关联的未取消键已无效、其通道已注销，而且与此选择器关联的全部其它资源已释放。
假设此选择器已经关闭。则调用此方法无效。
关闭选择器后，除了调用此方法或 wakeup 方法外，以不论什么其它方式继续使用它都将导致抛出 ClosedSelectorException。
3）java.nio.channels.SocketChannel
套接字通道不是连接网络套接字的完整抽象。必须通过调用 socket 方法所获得的关联 Socket 对象来完毕对套接字选项的绑定、关闭和操作。
不可能为随意的已有套接字创建通道，也不可能指定与套接字通道关联的套接字所使用的 SocketImpl 对象。
通过调用此类的某个 open 方法创建套接字通道。新创建的套接字通道已打开，但尚未连接。试图在未连接的通道上调用 I/O 操作将导致抛出 NotYetConnectedException。可通过调用套接字通道的 connect 方法连接该通道；一旦连接后，关闭套接字通道之前它会一直保持已连接状态。可通过调用套接字通道的 isConnected 方法来确定套接字通道是否已连接。
套接字通道支持非堵塞连接：可创建一个套接字通道。而且通过 connect 方法能够发起到远程套接字的连接，之后通过 finishConnect 方法完毕该连接。
可通过调用 isConnectionPending 方法来确定是否正在进行连接操作。
可单独地关闭 套接字通道的输入端和输出端，而无需实际关闭该通道。调用关联套接字对象的 shutdownInput 方法来关闭某个通道的输入端将导致该通道上的兴许读取操作返回 -1（指示流的末尾）。调用关联套接字对象的 shutdownOutput 方法来关闭通道的输出端将导致该通道上的兴许写入操作抛出 ClosedChannelException。
套接字通道支持异步关闭，这与 Channel 类中所指定的异步 close 操作类似。假设一个线程关闭了某个套接字的输入端。而同一时候还有一个线程被堵塞在该套接字通道上的读取操作中，那么处于堵塞线程中的读取操作将完毕，而不读取不论什么字节且返回 -1。I假设一个线程关闭了某个套接字的输出端，而同一时候还有一个线程被堵塞在该套接字通道上的写入操作中，那么堵塞线程将收到 AsynchronousCloseException。
多个并发线程可安全地使用套接字通道。虽然在随意给定时刻最多仅仅能有一个线程进行读取和写入操作，但数据报通道支持并发的读写。
connect 和 finishConnect 方法是相互同步的，假设正在调用当中某个方法的同一时候试图发起读取或写入操作，则在该调用完毕之前该操作被堵塞。
3、实例代码演示
Selector mSelector = null;
ByteBuffer sendBuffer = null;
SocketChannel client = null;
InetSocketAddress isa = null;
SocketEventListener mSocketEventListener = null;
private boolean Connect(String site, int port)
{
if (mSocketEventListener != null)
{
mSocketEventListener.OnSocketPause();
}
boolean ret = false;
try
{
mSelector = Selector.open();
client = SocketChannel.open();
client.socket().setSoTimeout(5000);
isa = new InetSocketAddress(site, port);
boolean isconnect = client.connect(isa);
// 将客户端设定为异步
client.configureBlocking(false);
// 在轮讯对象中注冊此客户端的读取事件(就是当server向此客户端发送数据的时候)
client.register(mSelector, SelectionKey.OP_READ); long waittimes = 0; if(!isconnect)
{
while (!client.finishConnect())
{
EngineLog.redLog(TAG, "等待非堵塞连接建立....");
Thread.sleep(50);
if(waittimes < 100)
{
waittimes++;
}
else
{
break;
}
}
}
Thread.sleep(500);
haverepaired();
startListener();
ret = true;
}
catch (Exception e)
{
EngineLog.redLog(TAG + " - Connect error", e != null ? e.toString() : "null");
try
{
Thread.sleep(1000 * 10);
}
catch (Exception e1)
{
EngineLog.redLog(TAG + " - Connect error", e1 != null ? e1.toString() : "null");
}
ret = false;
}
return ret;
}
SocketEventListener接口：
public interface SocketEventListener
{
/**
* Socket正在接收数据
* */
public void OnStreamRecive();
/**
* Socket接收数据完毕
* */
public void OnStreamReciveFinish();
/**
* Socket有新的消息返回
* */
public void OnStreamComing(byte[] aStreamData);
/**
* Socket出现异常
* */
public void OnSocketPause();
/**
* Socket已修复,可用
* */
public void OnSocketAvaliable();
}
监听接口的使用：
rivate void startListener()
{
if (mReadThread == null || mReadThread.isInterrupted())
{
mReadThread = null;
mReadThread = new Thread()
{
@Override
public void run()
{
while (!this.isInterrupted() && mRunRead)
{
MyLineLog.redLog(TAG,"startListener:" + mSendMsgTime);
try
{
// 假设client连接没有打开就退出循环
if (!client.isOpen())
break;
// 此方法为查询是否有事件发生假设没有就堵塞,有的话返回事件数量
int eventcount = mSelector.select();
// 假设没有事件返回循环
if (eventcount > 0)
{
starttime = CommonClass.getCurrentTime();
// 遍例全部的事件
for (SelectionKey key : mSelector.selectedKeys())
{
// 删除本次事件
mSelector.selectedKeys().remove(key);
// 假设本事件的类型为read时,表示server向本client发送了数据
if (key.isValid() && key.isReadable())
{
if (mSocketEventListener != null)
{
mSocketEventListener.OnStreamRecive();
}
boolean readresult = ReceiveDataBuffer((SocketChannel) key.channel()); if (mSocketEventListener != null)
{
mSocketEventListener.OnStreamReciveFinish();
} if(readresult)
{
key.interestOps(SelectionKey.OP_READ);
sleep(200);
}
else
{
throw new Exception();
}
}
key = null;
}
mSelector.selectedKeys().clear();
}
}
catch (Exception e)
{
mRunRead = false;
mReadThread = null;
if(e instanceof InterruptedException)
{
MyLineLog.redLog(TAG, "startListener:" + e.toString());
}
else
{
break;
}
}
}
}
};
mReadThread.setName(TAG + " Listener, " + CommonClass.getCurrentTime());
mRunRead = true;
mReadThread.start();
}
}
public boolean SendSocketMsg(byte[] aMessage) throws IOException
{
boolean ret = false;
try
{
sendBuffer.clear();
sendBuffer = ByteBuffer.wrap(aMessage);
int sendsize = client.write(sendBuffer);
sendBuffer.flip();
sendBuffer.clear();
mSendMsgTime = CommonClass.getCurrentTime();
MyLineLog.redLog(TAG, "SendSocketMsg:" + mSendMsgTime + ", sendsize:" + sendsize);
ret = true;
}
catch (Exception e)
{
MyLineLog.redLog(TAG, "发送数据失败。"); if (mSocketEventListener != null)
{
mSocketEventListener.OnSocketPause();
}
// crash();
}
return ret;
}
由于实际工作须要，我们须要常常会碰到两个问题。无效数据和大数据，怎样去解决问题呢，无效数据用过滤，大数据用分块接收。以下是接收数据的方法：
private boolean ReceiveDataBuffer(SocketChannel aSocketChannel)
{
// n 有数据的时候返回读取到的字节数。
// 0 没有数据而且没有达到流的末端时返回0。
// -1 当达到流末端的时候返回-1。 boolean ret = false; ByteArrayBuffer bab = new ByteArrayBuffer(8*1024);
while(true)
{
try
{
ByteBuffer readBuffer = ByteBuffer.allocate(1024 * 1);
readBuffer.clear();
int readsize = aSocketChannel.read(readBuffer); if(readsize > 0)
{
MyLineLog.redLog(TAG, "aSocketChannel.read=>" + readsize);
byte[] readbytes = readBuffer.array();
bab.append(readbytes, 0, readsize);
readBuffer.clear();
readBuffer.flip();
ret = true;
}
else if(readsize == 0)
{
int buffersize = bab.length();
byte[] readdata = bab.buffer();
int readdataoffset = 0;
boolean parsedata = true; while(readdataoffset < buffersize && parsedata)
{
byte datatype = readdata[readdataoffset];
if (datatype == PushUtils.PACKAGETYPE_HEARTBEAT || datatype == PushUtils.PACKAGETYPE_HEARTBEAR_NODATA)
{
byte[] blockdata = new byte[] { datatype };
ReceiveData(blockdata);
readdataoffset += 1;
blockdata = null;
}
else
{
byte[] blocklength = new byte[4];
System.arraycopy(readdata, readdataoffset + 5, blocklength, 0, 4);
int blocksize = CommonClass.bytes2int(CommonClass.LitteEndian_BigEndian(blocklength));
blocklength = null; int blockdatasize = 5 + blocksize + 4; if(blockdatasize <= buffersize)
{
MyLineLog.redLog(TAG, "块数据大小：" + blockdatasize);
byte[] blockdata = new byte[blockdatasize];
System.arraycopy(readdata, readdataoffset, blockdata, 0, blockdatasize); long starttime = CommonClass.getCurrentTime();
ReceiveData(blockdata);
long endtime = CommonClass.getCurrentTime();
MyLineLog.redLog(TAG, "解析数据用时：" + (endtime - starttime) + "ms");
readdataoffset += blockdatasize;
blockdata = null;
}
else if(blockdatasize < 10240)
{//小于10k，则属于正常包
MyLineLog.redLog(TAG, "块数据大小:" + blockdatasize + ",小于10k，说明数据不完整。继续获取。");
//将未解析数据存到暂时buffer
int IncompleteSize = buffersize - readdataoffset;
if(IncompleteSize > 0)
{
byte[] Incompletedata = new byte[IncompleteSize];
System.arraycopy(readdata, readdataoffset, Incompletedata, 0, IncompleteSize);
bab.clear();
bab.append(Incompletedata, 0, IncompleteSize);
parsedata = false;
Incompletedata = null;
}
}
else
{//异常包
MyLineLog.yellowLog(TAG, "块数据错误大小：" + blockdatasize);
MyLineLog.redLog(TAG,"blockdatasize error:" + blockdatasize);
ret = true;
break;
}
}
} if(parsedata)
{
ret = true;
break;
}
}
else if(readsize == -1)
{
ret = false;
break;
}
else
{
ret = true;
break;
}
}
catch (IOException e)
{
MyLineLog.redLog(TAG, "aSocketChannel IOException=>" + e.toString());
ret = false;
break;
}
}
bab.clear();
bab = null;
return ret;
}
假设数据量过大的话。还会使用压缩方法进行传输。那应该怎样接收呢，以下是一段接收压缩数据的方法：
private void ReceiveData(byte[] aDataBlock)
{
try
{
MyLineLog.redLog(TAG, "ReceiveData:" + mSendMsgTime);
if (mSendMsgTime != 0)
{
mSendMsgTime = 0;
} byte[] ret = null; int offset = 0; byte datatype = aDataBlock[offset];
offset += 1; if (datatype != -1)
{
if (datatype == PushUtils.PACKAGETYPE_HEARTBEAT)
{
ret = new byte[] { datatype };
}
else if (datatype == PushUtils.PACKAGETYPE_HEARTBEAR_NODATA)
{
ret = new byte[] { datatype };
}
else if (datatype == PushUtils.PACKAGETYPE_NORMAL || datatype == PushUtils.PACKAGETYPE_HEARTBEAR_HAVEDATA)
{
byte[] databytelength = new byte[4];
System.arraycopy(aDataBlock, offset, databytelength, 0, 4);
offset += 4;
int header = CommonClass.bytes2int(CommonClass.LitteEndian_BigEndian(databytelength));
databytelength = null; if (header == PushUtils.PACKAGEHEADER)
{
byte[] datalengthbyte = new byte[4];
System.arraycopy(aDataBlock, offset, datalengthbyte, 0, 4);
offset += 4; int datalength = CommonClass.bytes2int(CommonClass.LitteEndian_BigEndian(datalengthbyte));
datalengthbyte = null; if (datalength > 4)
{
// compressed bit 临时不压缩
byte compressed = aDataBlock[offset];
offset += 1; if (compressed == 1)
{//解压缩
//跳过头4个字节，此处用于解压缩后的数据大小，临时不须要
offset += 4;
int contentlength = datalength - 1 - 4;
byte[] datacontentbyte = new byte[contentlength];
System.arraycopy(aDataBlock, offset, datacontentbyte, 0, contentlength);
offset += contentlength; byte[] compressdata = new byte[contentlength - 4];
System.arraycopy(datacontentbyte, 0, compressdata, 0, contentlength - 4); long starttime = CommonClass.getCurrentTime();
byte[] decompressdatacontentbyte = CommonClass.decompress(compressdata);
long endtime = CommonClass.getCurrentTime();
MyLineLog.redLog(TAG, "解压缩数据用时：" + (endtime - starttime) + "ms");
int decompressdatacontentbytelength = decompressdatacontentbyte.length;
compressdata = null;
int footer = PushUtils.getInt(datacontentbyte, contentlength - 4); if (footer == PushUtils.PACKAGEFOOTER)
{
ret = new byte[decompressdatacontentbytelength + 1];
ret[0] = datatype;
System.arraycopy(decompressdatacontentbyte, 0, ret, 1, decompressdatacontentbytelength);
datacontentbyte = null;
decompressdatacontentbyte = null;
}
}
else
{//数据未压缩
int contentlength = datalength - 1;
byte[] datacontentbyte = new byte[contentlength];
System.arraycopy(aDataBlock, offset, datacontentbyte, 0, contentlength);
offset += contentlength; int footer = PushUtils.getInt(datacontentbyte, contentlength - 4); if (footer == PushUtils.PACKAGEFOOTER)
{
ret = new byte[contentlength + 1 - 4];
ret[0] = datatype;
System.arraycopy(datacontentbyte, 0, ret, 1, contentlength - 4);
datacontentbyte = null;
}
}
}
}
} if (mSocketEventListener != null)
{
mSocketEventListener.OnStreamComing(ret);
}
}
}
catch (Exception e)
{
MyLineLog.redLog(TAG + " - ReceiveData error", e.toString());
}
}
在介绍SocketChannel的时候。api提到关闭须要注意事项。以下一段关闭SocketChannel的演示样例代码：
public void closeSocket()
{
mRunRead = false;
if (mReadThread != null)
{
if (!mReadThread.isInterrupted())
{
mReadThread.interrupt();
mReadThread = null;
}
} if (mSelector != null && mSelector.isOpen())
{
try
{
mSelector.close();
}
catch (IOException e)
{
MyLineLog.redLog(TAG + " - closeSocket error", e.toString());
}
mSelector = null;
} if (client != null)
{
try
{
client.close();
client = null;
}
catch (IOException e)
{
MyLineLog.redLog(TAG + " - closeSocket2 error", e.toString());
}
} System.gc();
}
这篇文章解说部分大量參照JavaApi，事实上非常多问题的答案就在Api里面，当你不知道怎样去做的时候。回头看一下Api。细致思考一下，就能解决大部分问题。
android中非堵塞socket通信的更多相关文章
- Android简单实现Socket通信，client连接server后，server向client发送文字数据
案例实现的是简单的Socket通信,当client(Androidclient)连接到指定server以后,server向client发送一句话文字信息(你能够拓展其他的了) 先看一下服务端程序的实现 ...
- 从零开始学android -- 简易的socket通信
先来介绍下socket,网上摘抄点资料,免得自己打字了 网络中进程之间如何通信? 本地的进程间通信(IPC)有很多种方式,但可以总结为下面4类: 1.消息传递(管道.FIFO.消息队列) 2.同步(互 ...
- Android进程间通信之socket通信
用Java中的socket编程. 通过socket实现两个应用之间的通信,可以接收和发送数据,同时将接收到的数据显示在activity界面上. Server端: ServerLastly.java p ...
- android wifi热点 socket通信
1.首先建立wifi热点服务器 wifi客户端连接 2.开启一个子线程循环监听某个端口,进行数据流输入输出 /* 服务器 接收数据 */ class Receiver extends Thread ...
- Android 网络编程 Socket
1.服务端开发 创建一个Java程序 public class MyServer { // 定义保存所有的Socket,与客户端建立连接得到一个Socket public static List< ...
- Android开发--Socket通信
一.Socket通信简介 Android与服务器的通信方式主要有两种,一是Http通信,一是Socket通信.两者的最大差异在于,http连接使用的是"请求-响应方式",即在请求时 ...
- Socket 通信原理(Android客户端和服务器以TCP&&UDP方式互通)
转载地址:http://blog.csdn.net/mad1989/article/details/9147661 ZERO.前言 有关通信原理内容是在网上或百科整理得到,代码部分为本人所写,如果不当 ...
- 非堵塞socket实现android手机与PC的文件传输
项目须要是通过WIFI建立手机和PC的通信,然后自己定义一个简单的协议对要传输的文件进行校验,传输的文件是2张3M的图片,要求考虑网络中断情况处理. 我这里採用的是非堵塞socket来实现的,之前查过 ...
- 基于android的Socket通信
一.Socket通信简介 Android与服务器的通信方式主要有两种,一是Http通信,一是Socket通信.两者的最大差异在于,http连接使用的是“请求—响应方式”,即在请求时建立连接通道,当客户 ...
随机推荐
- Android消息推送解决方案
前言 消息推送在Android开发中应用的场景是越来越多了,比如说电商产品进行活动宣传.资讯类产品进行新闻推送等等,如下图: 推送消息截图 本文将介绍Android中实现消息推送的7种主流解决方案 目 ...
- npoi导出excel 导出List<T>
using System.Collections.Generic; using NPOI.HSSF.UserModel; using NPOI.SS.UserModel; using NPOI.XSS ...
- 封装一下webform的公用方法：对于软件我把这些全封装在pagebase里面，这样所有的页面只调用一句 Init()即可，其他的全在页面上配置
/// <summary> /// 绑定新闻列表,带分页与查询 /// </summary> /// <param n ...
- php 计算函数执行时间的方法及获得微妙的方法
// 获得微妙方法 function getMillisecond() { list($s1, $s2) = explode(' ', microtime()); return (float)spri ...
- 飞扬的小鸟（NOIP2014）（丧病DP题）
原题传送门 刚开始我还以为这道题目非常的简单.. 然后随便打了一个DP,直接WA,被zxyer狠狠地D了一顿. 然后发现有好多细节.. 首先假如某横坐标没有管子,那么l[x]=0;h[x]=m+1; ...
- commons-lang3中DateUtils类方法介绍
添加commons-lang3的Maven依赖 <dependency> <groupId>org.apache.commons</groupId> <art ...
- PDF工具
PDF打印工具 pdfcreator 可以将所有文件都打印为pdf PDF 阅读-编辑-打印工具 Adobe Acrobat DC 可以将所有文件都打印为pdf,并且支持编辑PDF与阅读,可以将PDF ...
- Mysql数据库乱码总结
今天又独到了Mysql乱码问题,过去总是匆匆的解决了就算了.这次我实在受不了了.每次都是迷迷糊糊的改好的. 这次决定好好探索一把,看了很多资料及博客之后才理解了点.先记录下来.如有不对的请指正. 1. ...
- oracle修改字段类型由varchar2修改为clob类型
oracle修改字段类型由varchar2修改为clob类型 http://blog.sina.com.cn/s/blog_9d12d07f0102vxis.html
- MSSQL横列转纵列
上篇我们说到了纵列转横列,这篇讲下横列转纵列,具体代码: 1.建表 CREATE TABLE [dbo].[EndLongChangeAcross]( ,) NOT NULL, ) NOT NULL, ...