对于阻塞并不是单线程，而是一种进程空等待的一个概念，例如对Socket的read（write、contect）的方法。本身并不阻塞，但是服务端并不知道是否会有数据发送过来，这个情况下的等待就叫做线程阻塞。
三大IO流简介：
一、BIO(IO Block):完全的线程阻塞，即等待
BIO是Blocking IO的意思。在类似于网络中进行read, write, connect一类的系统调用时会被卡住。
举个例子，当用read去读取网络的数据时，是无法预知对方是否已经发送数据的。因此在收到数据之前，能做的只有等待，直到对方把数据发过来，或者等到网络超时。
对于单线程的网络服务，这样做就会有卡死的问题。因为当等待时，整个线程会被挂起，无法执行，也无法做其他的工作。
于是，网络服务为了同时响应多个并发的网络请求，必须实现为多线程的。每个线程处理一个网络请求。线程数随着并发连接数线性增长。这的确能奏效。实际上2000年之前很多网络服务器就是这么实现的。但这带来两个问题：
1、线程越多，上下文切换就越多，而上下文切换时一个比较重的操作，会无所浪费大量的CPU。
2、每个线程会占用一定的内存作为线程的栈。比如有1000个线程同时运行，每个占用1MB内存，就会占用了1个G的内存。
问题的关键在于，当调用read接受网络请求时，有数据到了就用，没数据到时，实际上是可以干别的。使用大量线程，仅仅是因为Block发生，没有其他办法。
当然你可能会说，是不是可以弄个线程池呢？这样既能并发的处理请求，又不会产生大量线程。但这样会限制最大并发的连接数。比如你弄4个线程，那么最大4个线程都Block了就没法响应更多请求了。
BIO通讯模型
如图，每一个客户端经过向Acceptor请求连接，服务端都需要为之创建一个新的线程服务，且该线程在期间无法做任何事情。
当然，你也可以利用线程池实现成上图这样的伪异步IO，这时服务端能同时处理的请求就是线程池中的最大线程数。
二、NIO（）
该文是对NIO知识的归纳与整理
1.阻塞与同步
1）阻塞(Block)和非租塞(NonBlock):
阻塞和非阻塞是进程在访问数据的时候，数据是否准备就绪的一种处理方式，当数据没有准备的时候阻塞：往往需要等待缞冲区中的数据准备好过后才处理其他的事情，否則一直等待在那里。
非阻塞：当我们的进程访问我们的数据缓冲区的时候，如果数据没有准备好则直接返回，不会等待。如果数据已经准备好，也直接返回
2）同步(Synchronization)和异步(Async)的方式：
同步和异步都是基于应用程序私操作系统处理IO事件所采用的方式，比如同步：是应用程序要直接参与IO读写的操作。异步：所有的IO读写交给搡作系统去处理，应用程序只需要等待通知。
同步方式在处理IO事件的时候，必须阻塞在某个方法上靣等待我们的IO事件完成(阻塞IO事件或者通过轮询IO事件的方式）.对于异步来说，所有的IO读写都交给了搡作系统。这个时候，我们可以去做其他的事情，并不拓要去完成真正的IO搡作，当搡作完成IO后.会给我们的应用程序一个通知
同步：阻塞到IO事件，阻塞到read成则write。这个时候我们就完全不能做自己的事情，让读写方法加入到线程里面，然后阻塞线程来实现，对线程的性能开销比较大，
参考：https://blog.csdn.net/CharJay_Lin/article/details/81259880
2.BIO与NIO对比
block IO与Non-block IO
1）区别
|
IO模型 |
IO |
NIO |
|
方式 |
从硬盘到内存 |
从内存到硬盘 |
|
通信 |
面向流（乡村公路） |
面向缓存（高速公路，多路复用技术） |
|
处理 |
阻塞IO（多线程） |
非阻塞IO（反应堆Reactor） |
|
触发 |
无 |
选择器（轮询机制） |
2）面向流与面向缓冲
Java NIO和IO之间第一个最大的区别是，IO是面向流的.NIO是面向缓冲区的。Java IO面向流意味着毎次从流中读一个成多个字节，直至读取所有字节，它们没有被缓存在任何地方，此外，它不能前后移动流中的数据。如果需要前后移动从流中读取的教据，需要先将它缓存到一个缓冲区。Java NIO的缓冲导向方法略有不同。数据读取到一个它稍后处理的缓冲区，霱要时可在缓冲区中前后移动。这就增加了处理过程中的灵活性。但是，还需要检查是否该缓冲区中包含所有您需要处理的数裾。而且，需确保当更多的数据读入缓冲区时，不要覆盖缓冲区里尚未处理的数据。
3）阻塞与非阻塞
Java IO的各种流是阻塞的。这意味着，当一个线程调用read() 或 write()时，该线程被阻塞，直到有一些数据被读取，或数据完全写入。该线程在此期间不能再干任何事情了。 Java NIO的非阻塞模式，使一个线程从某通道发送请求读取数据，但是它仅能得到目前可用的数据，如果目前没有数据可用时，就什么都不会获取。而不是保持线程阻塞，所以直至数据变的可以读取之前，该线程可以继续做其他的事情。
非阻塞写也是如此。一个线程请求写入一些数据到某通道，但不需要等待它完全写入，这个线程同时可以去做别的事情。
线程通常将非阻塞IO的空闲时间用于在其它通道上执行IO操作，所以一个单独的线程现在可以管理多个输入和输出通道（channel）。
4）选择器（Selector)
Java NIO的选择器允许一个单独的线程来监视多个输入通道，你可以注册多个通道使用一个选择器，然后使用一个单独的线程来“选择"通道：这些通里已经有可以处理的褕入，或者选择已准备写入的通道。这选怿机制，使得一个单独的线程很容易来管理多个通道。
5）NIO和BIO读取文件
BIO读取文件：
BIO从一个阻塞的流中一行一行的读取数据
NIO读取文件：
通道是数据的载体，buffer是存储数据的地方，线程每次从buffer检查数据通知给通道
6）处理数据的线程数
NIO：一个线程管理多个连接
BIO：一个线程管理一个连接
3.NIO简介
在Java1.4之前的I/O系统中，提供的都是面向流的I/O系统，系统一次一个字节地处理数据，一个输入流产生一个字节的数据，一个输出流消费一个字节的数据，面向流的I/O速度非常慢，而在Java 1.4中推出了NIO，这是一个面向块的I/O系统，系统以块的方式处理处理，每一个操作在一步中产生或者消费一个数据库，按块处理要比按字节处理数据快的多。
在NIO中有几个核心对象需要掌握：缓冲区（Buffer）、通道（Channel）、选择器（Selector）。
4.缓冲区Buffer
缓冲区实际上是一个容器对象，更直接的说，其实就是一个数组，在NIO库中，所有数据都是用缓冲区处理的。在读取数据时，它是直接读到缓冲区中的； 在写入数据时，它也是写入到缓冲区中的；任何时候访问 NIO 中的数据，都是将它放到缓冲区中。而在面向流I/O系统中，所有数据都是直接写入或者直接将数据读取到Stream对象中。
在NIO中，所有的缓冲区类型都继承于抽象类Buffer，最常用的就是ByteBuffer，对于Java中的基本类型，基本都有一个具体Buffer类型与之相对应，它们之间的继承关系如下图所示：
1）其中的四个属性的含义分别如下：
容量（Capacity）：缓冲区能够容纳的数据元素的最大数量。这一个容量在缓冲区创建时被设定，并且永远不能改变。
上界(Limit)：缓冲区的第一个不能被读或写的元素。或者说,缓冲区中现存元素的计数。
位置(Position)：下一个要被读或写的元素的索引。位置会自动由相应的 get( )和 put( )函数更新。
标记(Mark)：下一个要被读或写的元素的索引。位置会自动由相应的 get( )和 put( )函数更新。
2）Buffer的常见方法如下所示:
flip(): 写模式转换成读模式
rewind()：将 position 重置为 0 ，一般用于重复读。
clear() ：
compact(): 将未读取的数据拷贝到 buffer 的头部位。
mark(): reset():mark 可以标记一个位置，
reset 可以重置到该位置。
Buffer 常见类型： ByteBuffer 、 MappedByteBuffer 、 CharBuffer 、 DoubleBuffer 、 FloatBuffer 、 IntBuffer 、 LongBuffer 、 ShortBuffer 。
3）基本操作
Buffer基础操作：
缓冲区分片，缓冲区分配，直接缓存区，缓存区映射，缓存区只读：
4）缓冲区存取数据流程
存数据时position会++，当停止数据读取的时候
调用flip()，此时limit=position，position=0
读取数据时position++，一直读取到limit
clear() 清空 buffer ，准备再次被写入 (position 变成 0 ， limit 变成 capacity) 。
5.通道Channel
通道是一个对象，通过它可以读取和写入数据，当然了所有数据都通过Buffer对象来处理。我们永远不会将字节直接写入通道中，相反是将数据写入包含一个或者多个字节的缓冲区。同样不会直接从通道中读取字节，而是将数据从通道读入缓冲区，再从缓冲区获取这个字节。
在NIO中，提供了多种通道对象，而所有的通道对象都实现了Channel接口。它们之间的继承关系如下图所示：
1）使用NIO读取数据
在前面我们说过，任何时候读取数据，都不是直接从通道读取，而是从通道读取到缓冲区。所以使用NIO读取数据可以分为下面三个步骤：
从FileInputStream获取Channel
创建Buffer
将数据从Channel读取到Buffer中
例子：
package com.charjay.nio.channel;
import java.io.FileInputStream;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
public class FileInputProgram {
static public void main( String args[] ) throws Exception {
FileInputStream fin = new FileInputStream("c:\\test.txt");
// 获取通道
FileChannel fc = fin.getChannel();
// 创建缓冲区
ByteBuffer buffer = ByteBuffer.allocate(1024);
// 读取数据到缓冲区
fc.read(buffer);
buffer.flip();
while (buffer.remaining() > 0) {
byte b = buffer.get();
System.out.print(((char)b));
}
fin.close();
}
}
2）使用NIO写入数据
使用NIO写入数据与读取数据的过程类似，同样数据不是直接写入通道，而是写入缓冲区，可以分为下面三个步骤：
从FileInputStream获取Channel
创建Buffer
将数据从Channel写入到Buffer中
例子：
package com.charjay.nio.channel;
import java.io.FileOutputStream;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
public class FileOutputProgram {
static private final byte message[] = { 83, 111, 109, 101, 32,
98, 121, 116, 101, 115, 46 };
static public void main( String args[] ) throws Exception {
FileOutputStream fout = new FileOutputStream( "e:\\test.txt" );
FileChannel fc = fout.getChannel();
ByteBuffer buffer = ByteBuffer.allocate( 1024 );
for (int i=0; i<message.length; ++i) {
buffer.put( message[i] );
}
buffer.flip();
fc.write( buffer );
fout.close();
}
}
6.反应堆
1）阻塞IO模型
在老的IO包中，serverSocket和socket都是阻塞式的，因此一旦有大规模的并发行为，而每一个访问都会开启一个新线程。这时会有大规模的线程上下文切换操作（因为都在等待，所以资源全都被已有的线程吃掉了），这时无论是等待的线程还是正在处理的线程，响应率都会下降，并且会影响新的线程。
2）NIO
Java NIO是在jdk1.4开始使用的，它既可以说成“新IO”，也可以说成非阻塞式I/O。下面是java NIO的工作原理：
1.由一个专门的线程来处理所有的IO事件，并负责分发。
2.事件驱动机制：事件到的时候触发，而不是同步的去监视事件。
3.线程通讯：线程之间通过wait,notify等方式通讯。保证每次上下文切换都是有意义的。减少无谓的线程切换。
注：每个线程的处理流程大概都是读取数据，解码，计算处理，编码，发送响应。
7.选择器
传统的 server / client 模式会基于 TPR ( Thread per Request ) ．服务器会为每个客户端请求建立一个线程．由该线程单独负贵处理一个客户请求。这种模式带未的一个问题就是线程数是的剧增．大量的线程会增大服务器的开销，大多数的实现为了避免这个问题，都采用了线程池模型，并设置线程池线程的最大数量，这又带来了新的问题，如果线程池中有 200 个线程，而有 200 个用户都在进行大文件下载，会导致第 201 个用户的请求无法及时处理，即便第 201 个用户只想请求一个几 KB 大小的页面。传统的 Sorvor / Client 模式如下围所示：
NIO 中非阻塞IO采用了基于Reactor模式的工作方式，IO调用不会被阻塞，相反是注册感兴趣的特点IO事件，如可读数据到达，新的套接字等等，在发生持定率件时，系统再通知我们。 NlO中实现非阻塞IO的核心设计Selector，Selector就是注册各种IO事件的地方，而且当那些事件发生时，就是这个对象告诉我们所发生的事件。
当有读或者写等任何注册的事件发生时，可以从Selector中获得相应的SelectionKey，同时从SelectionKey中可以找到发生的事件和该事件所发生的具体的SelectableChannel，以获得客户端发送过来的数据。
使用NIO中非阻塞IO编写服务器处理程序，有三个步骤
1.向Selector对象注册感兴趣的事件
2.从Selector中获取感兴趣的事件
3.根据不同事件进行相应的处理
8.NIO源码分析
Selector是NIO的核心
epool模型
1）Selector
Selector的open()方法：
2）ServerSocketChannel
ServerSocketChannel.open()
9.AIO
Asynchronous IO
异步非阻塞IO
BIO ServerSocket
NIO ServerSocketChannel
AIO AsynchronousServerSocketChannel
AIO通信例子（异步阻塞与非阻塞）：
1. 异步阻塞
Future方式（异步阻塞）#
Future是在JDK1.5中加入Java并发包的，该接口提供get()方法用于获取任务完成之后的处理结果。
在AIO中，可以接受一个I/O连接请求，返回一个Future对象。
然后可以基于该返回对象进行后续的操作，包括使其阻塞、查看是否完成、超时异常。
使用异步Channel时，accept()、connect()、read()、write()等方法都不会阻塞，
也就是说如果使用返回Future的这些方法，程序并不能直到什么时候成功IO，
必须要使用get方法，等get方法的阻塞结束后才能确保IO完成，继续执行下面的操作。
FutureClient
public class ClientOnFuture {
static final int PORT = 10000;
static final String IP = "localhost";
static ByteBuffer buffer = ByteBuffer.allocateDirect(1024);
public static void main(String[] args) {
//尝试创建AsynchronousSocketChannel
try (AsynchronousSocketChannel socketChannel = AsynchronousSocketChannel.open()) {
//获取连接
Future<Void> connect = socketChannel.connect(new InetSocketAddress(IP, PORT));
//返回连接状态
Void aVoid = connect.get();
//返回null表示连接成功
if (aVoid == null) {
/**
* 向服务端发送数据
*/
Future<Integer> write = socketChannel.write(ByteBuffer.wrap("客户端说：我连接成功了！".getBytes()));
Integer integer = write.get();
System.out.println("服务端接收的字节长度：" + integer);
/**
* 接收服务端数据
*/
while (socketChannel.read(buffer).get() != -1) {
buffer.flip();
CharBuffer decode = Charset.defaultCharset().decode(buffer);
System.out.println(decode.toString());
if (buffer.hasRemaining()) {
buffer.compact();
} else {
buffer.clear();
}
int r = new Random().nextInt(10);
if (r == 5) {
System.out.println("客户端关闭！");
break;
} else {
/**
* 如果在频繁调用write()的时候，在上一个操作没有写完的情况下，
* 调用write会触发WritePendingException异常
*
* 应此此处最好在调用write()之后调用get()阻塞以便确认io操作完成
*/
socketChannel.write(ByteBuffer.wrap(("客户端发送的数据:" + r).getBytes())).get();
}
}
} else {
System.out.println("无法建立连接!");
}
} catch (Exception e) {
System.out.println("出错了！");
}
}
}
FutureServer
public class ServerOnFuture {
static final int PORT = 10000;
static final String IP = "localhost";
static ByteBuffer buffer = ByteBuffer.allocateDirect(1024);
public static void main(String[] args) {
try (AsynchronousServerSocketChannel serverSocketChannel = AsynchronousServerSocketChannel.open()) {
serverSocketChannel.bind(new InetSocketAddress(IP, PORT));
while (true) {
Future<AsynchronousSocketChannel> channelFuture = serverSocketChannel.accept();
try (AsynchronousSocketChannel socketChannel = channelFuture.get()) {
while (socketChannel.read(buffer).get() != -1) {
buffer.flip();
/**
* 此处要注意：千万不能直接操作buffer（因为write要用到buffer），否则客户端会阻塞并报错
* “java.util.concurrent.ExecutionException: java.io.IOException: 指定的网络名不再可用。”
*
* 缓冲区的复制有分两种：
* 1、完全复制：调用duplicate()函数或者asReadOnlyBuffer()函数
* 2、部分复制：调用slice函数
*
* duplicate()函数创建了一个与原始缓冲区相似的新缓冲区。
* 每个缓冲区有自己的位置信息，但对缓冲区的修改都会映射到同一个底层数组上。
*/
//复制一个缓冲区会创建一个新的 Buffer 对象，但并不复制数据。原始缓冲区和副本都会操作同样的数据元素。
ByteBuffer duplicate = buffer.duplicate();
CharBuffer decode = Charset.defaultCharset().decode(duplicate);
System.out.println("收到客户端数据：" + decode);
/**
* 写回数据(get()会阻塞以等待io操作完成)
*/
socketChannel.write(buffer).get();
/**
* 清理buffer，准备下一次read
*/
if (buffer.hasRemaining()) {
/**
* 如果未写完，表示buffer还有数据，则只清理写过的数据
* compact()方法只会清除已经读过的数据。
* 任何未读的数据都被移到缓冲区的起始处，新写入的数据将放到缓冲区未读数据的后面。
*/
buffer.compact();
} else {
buffer.clear();
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
2. 异步非阻塞和Group
AsynchronousChannelGroup是异步Channel的分组管理器，它可以实现资源共享。
创建AsynchronousChannelGroup时，需要传入一个ExecutorService，也就是绑定一个线程池。
该线程池负责两个任务：处理IO事件和触发CompletionHandler回调接口。
每个异步通道都必须关联一个组，要么是系统默认组，要么是用户创建的组。
如果不使用group参数，java使用一个默认的系统范围的组对象。
异步IO模型中，用户线程直接使用内核提供的异步IO API发起read请求。
发起后立即返回，继续执行用户线程代码。
此时用户线程已经将调用的AsynchronousOperation和CompletionHandler注册到内核，然后操作系统开启独立的内核线程去处理IO操作。
当read请求的数据到达时，由内核负责读取socket中的数据，并写入用户指定的缓冲区中。
最后内核将read的数据和用户线程注册的CompletionHandler分发给内部Proactor，Proactor将IO完成的信息通知给用户线程（一般通过调用用户线程注册的完成事件处理函数），完成异步IO。
Callback方式客户端：
package com.charjay.aio;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousSocketChannel;
import java.nio.channels.CompletionHandler;
import java.util.concurrent.CountDownLatch;
public class AIOClient {
private final AsynchronousSocketChannel client ;
public AIOClient() throws Exception{
//Asynchronous
//BIO Socket
//NIO SocketChannel
//AIO AsynchronousSocketChannel
//先把高速公路修起来
client = AsynchronousSocketChannel.open();
}
public void connect(String host,int port)throws Exception{
//开始发车，连上高速公路
//Viod什么都不是
//也是实现一个匿名的接口
//这里只做写操作
client.connect(new InetSocketAddress(host,port),null,new CompletionHandler<Void,Void>() {
//实现IO操作完成的方法
@Override
public void completed(Void result, Void attachment) {
try {
client.write(ByteBuffer.wrap(("这是一条测试数据" + System.currentTimeMillis()).getBytes())).get();
// System.out.println("已发送至服务器");
} catch (Exception ex) {
ex.printStackTrace();
}
}
//实现IO操作失败的方法
@Override
public void failed(Throwable exc, Void attachment) {
exc.printStackTrace();
}
});
//下面这一段代码是只读数据
final ByteBuffer bb = ByteBuffer.allocate(1024);
client.read(bb, null, new CompletionHandler<Integer,Object>(){
//实现IO操作完成的方法
@Override
public void completed(Integer result, Object attachment) {
//System.out.println("IO操作完成" + result);
System.out.println("获取反馈结果" + new String(bb.array()));
}
//实现IO操作失败的方法
@Override
public void failed(Throwable exc, Object attachment) {
exc.printStackTrace();
}
}
);
try {
Thread.sleep(Integer.MAX_VALUE);
} catch (InterruptedException ex) {
System.out.println(ex);
}
}
public static void main(String args[])throws Exception{
int count = 10;
final CountDownLatch latch = new CountDownLatch(count);
for (int i = 0; i < count; i ++) {
latch.countDown();
new Thread(){
public void run(){
try{
latch.await();
new AIOClient().connect("localhost",8080);
}catch(Exception e){
}
}
}.start();
}
Thread.sleep(1000 * 60 * 10);
}
}
Callback方式服务端：
public class ServerOnCompletionHandler {
static final int PORT = 8080;
static final String IP = "localhost";
public static void main(String[] args) {
//打开通道
try (final AsynchronousServerSocketChannel serverSocketChannel = AsynchronousServerSocketChannel.open()) {
//创建服务
serverSocketChannel.bind(new InetSocketAddress(IP, PORT));
//接收客户端连接
serverSocketChannel.accept(null, new CompletionHandler<AsynchronousSocketChannel, Void>() {
final ByteBuffer buffer = ByteBuffer.allocateDirect(1024);
@Override
public void completed(AsynchronousSocketChannel socketChannel, Void attachment) {
/**
* 注意接收一个连接之后，紧接着可以接收下一个连接，所以必须再次调用accept方法
* AsynchronousSocketChannel就代表该CompletionHandler处理器在处理连接成功时的result（AsynchronousSocketChannel的实例）
*/
serverSocketChannel.accept(null, this);
try {
while (socketChannel.read(buffer).get() != -1) {
buffer.flip();
final ByteBuffer duplicate = buffer.duplicate();
final CharBuffer decode = Charset.defaultCharset().decode(duplicate);
System.out.println(decode.toString());
socketChannel.write(buffer).get(); //get()用于阻塞使IO操作完成
if (buffer.hasRemaining()) {
buffer.compact();
} else {
buffer.clear();
}
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
socketChannel.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
@Override
public void failed(Throwable exc, Void attachment) {
/**
* 失败后也需要接收下一个连接
*/
serverSocketChannel.accept(null, this);
System.out.println("连接失败！");
}
});
//主要是阻塞作用，因为AIO是异步的，所以此处不阻塞的话，主线程很快执行完毕，并会关闭通道
System.in.read();
} catch (IOException e) {
e.printStackTrace();
}
}
}
GroupServer端：
package com.charjay.aio;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousChannelGroup;
import java.nio.channels.AsynchronousServerSocketChannel;
import java.nio.channels.AsynchronousSocketChannel;
import java.nio.channels.CompletionHandler;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* AIO的服务端
*/
public class AIOServer {
private final int port;
public static void main(String args[]) {
int port = 8080;
new AIOServer(port);
}
//注册一个端口，用来给客户端连接
public AIOServer(int port) {
this.port = port;
listen();
}
//侦听方法
private void listen() {
try {
//线程缓冲池，为了体现异步
ExecutorService executorService = Executors.newCachedThreadPool();
//给线程池初始化一个线程
AsynchronousChannelGroup threadGroup = AsynchronousChannelGroup.withCachedThreadPool(executorService, 1);
//Asynchronous异步
//BIO ServerSocket
//NIO ServerSocketChannel 有那么一点点像
//AIO AsynchronousServerSocketChannel
//同样的，也是先把高速公路修通
final AsynchronousServerSocketChannel server = AsynchronousServerSocketChannel.open(threadGroup);
//打开高速公路的关卡
server.bind(new InetSocketAddress(port));
System.out.println("服务已启动，监听端口" + port);
final Map<String,Integer> count = new ConcurrentHashMap<String, Integer>();
count.put("count", 0);
//开始等待客户端连接
//实现一个CompletionHandler 的接口，匿名的实现类
server.accept(null, new CompletionHandler<AsynchronousSocketChannel, Object>() {
final ByteBuffer buffer = ByteBuffer.allocateDirect(1024);
//实现IO操作完成的方法
public void completed(AsynchronousSocketChannel result, Object attachment) {
count.put("count", count.get("count") + 1);
System.out.println(count.get("count"));
//只要拿数据，捡现成的,我们都是懒人，IO操作都不用关心了
//System.out.println("IO操作成功，开始获取数据");
try {
buffer.clear();
result.read(buffer).get();
buffer.flip();
result.write(buffer);
buffer.flip();
} catch (Exception e) {
System.out.println(e.toString());
} finally {
try {
result.close();
server.accept(null, this);
} catch (Exception e) {
System.out.println(e.toString());
}
}
//System.out.println("操作完成");
}
//实现IO操作失败的方法
@Override
public void failed(Throwable exc, Object attachment) {
System.out.println("IO操作是失败: " + exc);
}
});
try {
Thread.sleep(Integer.MAX_VALUE);
} catch (InterruptedException ex) {
System.out.println(ex);
}
} catch (IOException e) {
System.out.println(e);
}
}
}
Netty在Double中的使用：
未完待续......
