概念理解
AIO编程，在NIO基础之上引入了异步通道的概念，并提供了异步文件和异步套接字通道的实现，从而在真正意义上实现了异步非阻塞，之前我们学习的NIO只是非阻寒而并非异步。而AIO它不需要通过多路复用器对注册的通道进行轮询操作即可实现异步读写，从而简化了NIO编程模型。也可以称之为NIO2.0，这种模式才真正的属于我们异步非阻寒的模型。
案例
Server.java
public class Server {
//线程池
private ExecutorService executorService;
//线程组
private AsynchronousChannelGroup threadGroup;
//服务器通道
public AsynchronousServerSocketChannel assc;
public Server(int port){
try {
//创建一个缓存池
executorService = Executors.newCachedThreadPool();
//创建线程组
threadGroup = AsynchronousChannelGroup.withCachedThreadPool(executorService, 1);
//创建服务器通道
assc = AsynchronousServerSocketChannel.open(threadGroup);
//进行绑定
assc.bind(new InetSocketAddress(port));
System.out.println("server start , port : " + port);
//进行阻塞
assc.accept(this, new ServerCompletionHandler());
//一直阻塞 不让服务器停止
Thread.sleep(Integer.MAX_VALUE);
} catch (Exception e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
Server server = new Server(8765);
}
}上面的代码都有注释，学了NIO相信这个步骤你也有所了解，不了解NIO的可以看我的上一篇文章。
ServerCompletionHandler.java
public class ServerCompletionHandler implements CompletionHandler<AsynchronousSocketChannel, Server> {
@Override
public void completed(AsynchronousSocketChannel asc, Server attachment) {
//当有下一个客户端接入的时候 直接调用Server的accept方法，这样反复执行下去，保证多个客户端都可以阻塞
attachment.assc.accept(attachment, this);
read(asc);
}
private void read(final AsynchronousSocketChannel asc) {
//读取数据
ByteBuffer buf = ByteBuffer.allocate(1024);
asc.read(buf, buf, new CompletionHandler<Integer, ByteBuffer>() {
@Override
public void completed(Integer resultSize, ByteBuffer attachment) {
//进行读取之后,重置标识位
attachment.flip();
//获得读取的字节数
System.out.println("Server -> " + "收到客户端的数据长度为:" + resultSize);
//获取读取的数据
String resultData = new String(attachment.array()).trim();
System.out.println("Server -> " + "收到客户端的数据信息为:" + resultData);
String response = "服务器响应, 收到了客户端发来的数据: " + resultData;
write(asc, response);
}
@Override
public void failed(Throwable exc, ByteBuffer attachment) {
exc.printStackTrace();
}
});
}
private void write(AsynchronousSocketChannel asc, String response) {
try {
ByteBuffer buf = ByteBuffer.allocate(1024);
buf.put(response.getBytes());
buf.flip();
asc.write(buf).get();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
@Override
public void failed(Throwable exc, Server attachment) {
exc.printStackTrace();
}
}
这里ServerCompletionHandler必须实现CompletionHandler接口
CompletionHandler有两个方法，分别是：
1) public void completed(AsynchronousSocketChannel asc, Server attachment)
2) public void failed(Throwable exc, Server attachment)
下面我们分别对这两个接口的实现进行分析：首先看completed接口的实现，我们从attachment获取成员变量AsynchronousServerSocketChannel，然后继续调用它的accept方法。可能读者在此可能会心存疑惑，既然已经接收客户端成功了，为什么还要再次调用accept方法呢？原因是这样的：当我们调用AsynchronousServerSocketChannel的accept方法后，如果有新的客户端连接接入，系统将回调我们传入的CompletionHandler实例的completed方法，表示新的客户端已经接入成功，因为一个AsynchronousServerSocketChannel可以接收成千上万个客户端，所以我们需要继续调用它的accept方法，接收其它的客户端连接，最终形成一个循环。每当接收一个客户读连接成功之后，再异步接收新的客户端连接。
Client.java
public class Client implements Runnable{
//创建客户端通道
private AsynchronousSocketChannel asc ;
public Client() throws Exception {
//打开通道
asc = AsynchronousSocketChannel.open();
}
public void connect(){
//连接通道
asc.connect(new InetSocketAddress("127.0.0.1", 8765));
}
public void write(String request){
try {
//往服务端发内容
asc.write(ByteBuffer.wrap(request.getBytes())).get();
//读取服务端的响应
read();
} catch (Exception e) {
e.printStackTrace();
}
}
private void read() {
ByteBuffer buf = ByteBuffer.allocate(1024);
try {
asc.read(buf).get();
buf.flip();
byte[] respByte = new byte[buf.remaining()];
buf.get(respByte);
System.out.println(new String(respByte,"utf-8").trim());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
}
@Override
public void run() {
//做个死循环让这个程序不要停下来
while(true){
}
}
public static void main(String[] args) throws Exception {
Client c1 = new Client();
c1.connect();
Client c2 = new Client();
c2.connect();
Client c3 = new Client();
c3.connect();
new Thread(c1, "c1").start();
new Thread(c2, "c2").start();
new Thread(c3, "c3").start();
Thread.sleep(1000);
c1.write("c1 aaa");
c2.write("c2 bbbb");
c3.write("c3 ccccc");
}
}
服务端运行结果：
客户端运行结果：
客户端运行后服务端的响应结果：
我们来看一下AsynchronousSocketChannel 底层实现了 读写操作 如下方法：
public abstract Future write(ByteBuffer src, long position);
public abstract Future read(ByteBuffer dst);
我们发现AIO不需要像NIO编程那样创建一个独立的IO线程处理读写操作，对于AsynchronousServerSocketChannel和AsynchronousSocketChannel，它们都由JDK底层的线程池负责回调并驱动读写操作。正因为如此，基于NIO2.0新的异步非阻塞Channel进行编程比NIO编程更简单。
BIO NIO AIO总结
好!到这目前为止 BIO NIO AIO(NIO2.0)都说完了，来总结一下他们之间的区别：
BIO：同步阻塞
NIO：同步非阻塞
AIO(NIO2.0)：异步非阻塞
IO (BIO)和NIO/NIO2.0的区别：其本质就是阻塞和非阻塞的区别
阻塞概念：应用程序在获取网络数据的时候，如果网络传输数据很慢，那么程序就一直等着，直到传输完毕为止。
非阻塞概念；应用程序直接可以获取己经准备就绪好的数据，无需等待。
同步和异步：同步和异步一般是面向操作系统与用程序对操作的层面上来区别的。
同步时，应用程序会直接参与IO读写操作，并且我们的应用程序会直接阻塞到某一个方法上，直到数据准备就绪；或者采用轮询的策略实时检查数据的就绪状态，如果就绪获取数据。
异步时，则所有IO读写操作交给操作系统处理。与我们的应用程序没有直接关系，我们程序不需要关心IO读写。当作系统完成了IO读写操作时，会给我们应用程序发送通知，我们的应用程序直接拿走数据即可。
同步说的是你的server服务器端的执行方式
阻塞说的是具体的技术，接收数据的方式、状态（IO、NIO）
NIO/NIO2.0自我感觉比起BIO好多了，但是 NIO/NIO2.0 API繁杂，用起来我个人感觉有点恶心，不易理解。开发出高质量的NIO/NIO2.0程序并不是一件简单的事情，除去NIO固有的复杂性和BUG不谈，作为一个NIO/NIO2.0服务端需要能够处理网络的闪断、客户端的重复接入、客户端的安全认证、消息的编解码、半包读写等等，如果你没有足够的NIO/NIO2.0编程经验积累，一个NIO/NIO2.0框架的稳定往往需要半年甚至更长的时间。更为糟糕的是一旦在生产环境中发生问题，往往会导致跨节点的服务调用中断，严重的可能会导致整个集群环境都不可用，需要重启服务器，这种非正常停机会带来巨大的损失。
不选择JAVA原生NIO/NIO2.0编程的原因
1) NIO的类库和API繁杂，使用麻烦，你需要熟练掌握Selector、ServerSocketChannel、SocketChannel、ByteBuffer等；
2) 需要具备其它的额外技能做铺垫，例如熟悉Java多线程编程，因为NIO编程涉及到Reactor模式，你必须对多线程和网路编程非常熟悉，才能编写出高质量的NIO程序；
3) 可靠性能力补齐，工作量和难度都非常大。例如客户端面临断连重连、网络闪断、半包读写、失败缓存、网络拥塞和异常码流的处理等等，NIO编程的特点是功能开发相对容易，但是可靠性能力补齐工作量和难度都非常大；
4) JDK NIO的BUG，例如臭名昭著的epoll bug，它会导致Selector空轮询，最终导致CPU 100%。官方声称在JDK1.6版本的update18修复了该问题，但是直到JDK1.7版本该问题仍旧存在，只不过该bug发生概率降低了一些而已，它并没有被根本解决。
好！说到这相信大家也知道我的用心，我们可以使用NIO框架Netty来进行NIO编程，它既可以作为客户端也可以作为服务端，同时支持UDP和异步文件传输，功能非常强大。
后面我会写专门的文章来介绍Netty的使用。
扫一扫
2018
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
