BIO
BIO意为阻塞IO（Blocking IO），即所有的通信方法如Accept，connect，read和write方法均阻塞。线程在大部分时间处于阻塞等待状态，无法支持高负载高并发的场景，资源利用率极为低下。
Java传统BIO是面向流的。流是一种单向的数据传输媒介。根据传输数据的不同，流总的来说分为字符流和字节流两种。其中字节流以Stream结尾，字符流以Reader/Writer结尾。
这些流有如下分类（只列出常用的）：
- InputStream：字节输入流
- BufferedInputStream：带缓冲的输入流
- FileInputStream：文件输入流
- ObjectInputStream：对象输入流，读入序列化的对象，要求对象必须实现Serializable接口
- DataInputStream：数据输入流，读取Java基本数据类型
- OutputStream：字节输出流
- BufferedOutputStream：带缓存的输出流
- FileOutputStream：文件输出流
- ObjectOutputStream：对象输出流
- DataOutputStream：数据输出流
- InputStreamReader：字符输出流
- BufferedReader：带缓存的字符输入流
- FileReader：文件字符输入流
- OutputStreamWriter：字节输入流
- BufferedWriter：带缓存的字符输出流
- FileWriter：文件字符输出流
下面是BIO网络通信的示例代码：
BioServer（BIO服务端）
public class BioServer {
public static void main(String[] args) throws Exception {
ServerSocket serverSocket = new ServerSocket(9900);
while (true) {
// 方法阻塞，等待socket建立连接
Socket socket = serverSocket.accept();
InputStream inputStream = socket.getInputStream();
BufferedInputStream bufferedInputStream = new BufferedInputStream(inputStream);
byte[] buffer = new byte[1024];
int read;
// 方法阻塞，等待接收到数据，或者是连接关闭
while ((read = bufferedInputStream.read(buffer)) != -1) {
System.out.println(new String(buffer, 0, read));
}
// 使用完毕后需要关闭socket
socket.close();
}
// 使用完毕后必须关闭相关资源，这里演示需要使用了死循环，故不需要关闭
// bufferedInputStream.close();
// inputStream.close();
// serverSocket.close();
}
}
BioClient（BIO客户端）
public class BioClient {
public static void main(String[] args) throws Exception {
Socket socket = new Socket();
// 阻塞方式，直到连接server成功
socket.connect(new InetSocketAddress("127.0.0.1", 9900));
OutputStream outputStream = socket.getOutputStream();
BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(outputStream);
bufferedOutputStream.write("Hello from client\n".getBytes());
// 由于是缓存流，write数据并不会被立即发送，需要使用flush将缓冲区所有数据写入流
bufferedOutputStream.flush();
bufferedOutputStream.close();
outputStream.close();
socket.close();
}
}
NIO
NIO意为New IO，即新一代IO。其他地方有介绍说Java NIO为非阻塞IO（Non-blocking IO）。这一点其实是不对的，因为Java的NIO既支持阻塞方式也支持非阻塞方式。
NIO相对传统IO，编程模型上做出了较大改变。NIO是面向通道(channel)和缓冲区(buffer)的。Channel和流最大的不同之处在于channel支持双向数据传递，而流只支持单向。
除此之外NIO还支持零拷贝。零拷贝即CPU不参与数据复制的过程，可以避免用户空间和操作系统内核空间的上下文切换。零拷贝不仅需要应用的支持，还需要操作系统的支持。下面举一个例子，我们从文件系统读取一个文件，从socket发送出去。如果用传统方式数据流经如下步骤：
文件系统 -> 内核读缓存 -> 应用缓存（Java） -> 内核Socket缓存 -> 网卡缓存
使用零拷贝技术之后，数据流经步骤减少了2次拷贝，如下所示：
文件系统 -> 内核读缓存 -> 内核Socket缓存 -> 网卡缓存
Linux系统支持的零拷贝有两种：
- mmap内存映射：DMA控制器从外部存储加载数据到内核缓存，然后将应用内缓存通过地址映射的方式，映射到内核缓存。这样可以省去数据从内核缓存复制到应用缓存的步骤。
- sendfile：DMA控制器从外部存储加载数据到内核缓存，然后系统直接将内核缓存中的数据复制到socket缓存。这样可以省去数据从应用缓存复制到socket缓存的步骤。
mmap的Java NIO使用方式：
MappedByteBuffer mappedByteBuffer = new RandomAccessFile(file, "r").getChannel().map(FileChannel.MapMode.READ_ONLY, 0, len);
该方法返回的mappedByteBuffer是文件数据的内核缓存在Java应用中的映射。
sendfile的Java NIO使用方式：
FileChannel sourceChannel = new RandomAccessFile("/path/to/file", "rw").getChannel();
SocketChannel socketChannel = SocketChannel.open(...);
sourceChannel.transferTo(0, sourceChannel.size(), socketChannel);
FileChannel的transferTo和transferFrom使用了零拷贝技术。transferTo负责将文件FileChannel的内容发往其他channel，transferFrom从其他channel读取内容，发送给FileChannel。
通过上面我们可以得出结论，减少内核缓存和应用缓存（主要指Java应用堆内存）之间的复制操作可以提高IO操作效率。为了满足这种场景，NIO的ByteBuffer提供了两种：堆内buffer和堆外buffer。堆内buffer使用一个字节数组作为数据载体，堆外内存不属于Java虚拟机，归操作系统管理。使用堆外内存能够显著提高IO性能。
ByteBuffer分配堆内内存和堆外内存的方式如下：
// 分配1024字节堆内内存
ByteBuffer byteBuffer = ByteBuffer.allocate(1024)
// 分配1024字节堆外内存
ByteBuffer byteBuffer = ByteBuffer.allocateDirect(1024)
阻塞NIO
下面举一个例子，介绍下阻塞模式的NIO网络通信的写法。
NioServer
public class NioServer {
public static void main(String[] args) throws Exception {
// 建立连接并绑定地址端口
ServerSocketChannel channel = ServerSocketChannel.open().bind(new InetSocketAddress("127.0.0.1", 9900));
// 创建一个1024字节大小的字节缓冲区
ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
while (true) {
// 接受socket连接关闭
// 方法阻塞，直到socket链接成功
SocketChannel socketChannel = channel.accept();
int read;
// 方法阻塞，直到读取到数据，或者socket连接关闭
while ((read = socketChannel.read(byteBuffer)) != -1) {
System.out.println(new String(byteBuffer.array(), 0, read));
byteBuffer.clear();
}
// 使用完需要关闭socketChannel
socketChannel.close();
}
// channel.close();
}
}
NioClient
public class NioClient {
public static void main(String[] args) throws Exception {
// 建立连接
SocketChannel socketChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 9900));
ByteBuffer byteBuffer = ByteBuffer.wrap("Hello from client".getBytes());
socketChannel.write(byteBuffer);
socketChannel.close();
}
}
非阻塞NIO
非阻塞NIO所有的数据传输方法比如accept connect read write均不阻塞。可以使用如下配置将阻塞NIO转变为非阻塞NIO：
channel.configureBlocking(false);
需要注意的是，FileChannel不支持非阻塞模式。
非阻塞NIO的数据传输方法都是非阻塞的，调用之后无论成功或者失败都立刻返回。但问题是，我们无法知道数据是否传送成功，什么时候可以去传送/接收数据，给编程造成了很大的困难。
为了解决这个问题，Java NIO提供了多路复用器：Selector。Selector以轮询的方式检查所有注册到该Selector下的所有channel的事件。一旦有channel准备好了连接，读或者写，Selector可以立刻检测到并处理该事件。
Selector的厉害之处在于能够使用一个线程来处理多个channel的连接和读写事件，避免了线程上下文切换，十分的高效。
Selector并不会主动去监听某个channel的某些事件。需要主动将channel需要被Selector检测的事件注册到Selector。
Channel的事件有如下4种：
- SelectionKey.OP_ACCEPT
- SelectionKey.OP_READ
- SelectionKey.OP_WRITE
- SelectionKey.OP_CONNECT
创建Selector和向Selector注册事件的方法为：
Selector selector = Selector.open();
channel.register(selector, SelectionKey.OP_ACCEPT);
如果需要Selector检测同一个channel的多个事件，可以通过按位或运算符合并事件。例如SelectionKey.OP_WRITE | SelectionKey.OP_READ。
下面是一个使用Selector的非阻塞NIO网络通信server的例子。该server接受到client发来的数据之后，回复“Hello from server”给客户端。
代码如下所示：
public class SelectorServer {
public static void main(String[] args) throws Exception {
ServerSocketChannel channel = ServerSocketChannel.open().bind(new InetSocketAddress("127.0.0.1", 9900));
// 设置为非阻塞模式
channel.configureBlocking(false);
Selector selector = Selector.open();
// 向selector注册ACCEPT事件，当ServerSocketChannel发生accept事件的时候会被selector select到
channel.register(selector, SelectionKey.OP_ACCEPT);
ByteBuffer buffer = ByteBuffer.allocate(1024);
ByteBuffer echoBuffer = ByteBuffer.wrap("Hello from server\n".getBytes());
while (true) {
// 方法阻塞
// selector一旦轮训到任何注册的channel发生的任意事件，立刻返回
selector.select();
Iterator iterator = selector.selectedKeys().iterator();
while (iterator.hasNext()) {
// 获取SelectionKey
SelectionKey selectionKey = iterator.next();
iterator.remove();
// 如果是Accept事件
if (selectionKey.isAcceptable()) {
// 接受socket连接，非阻塞
SocketChannel socketChannel = channel.accept();
// 注意，这里不要忘了设置socketChannel为非阻塞模式，否则register方法会报错
socketChannel.configureBlocking(false);
// 为socketChannel注册READ事件，channel可以接收数据
socketChannel.register(selector, SelectionKey.OP_READ);
// 如果是read事件
} else if (selectionKey.isReadable()) {
// 从SelectionKey获取附带的channel，即产生read事件的channel
SocketChannel socketChannel = (SocketChannel) selectionKey.channel();
int read = socketChannel.read(buffer);
System.out.println(new String(buffer.array(), 0, read));
buffer.clear();
// 设置接下来关心的事件为write
selectionKey.interestOps(SelectionKey.OP_WRITE);
// 如果是write事件
} else if (selectionKey.isWritable()) {
// 和read部分类似，获取触发事件的channel
SocketChannel socketChannel = (SocketChannel) selectionKey.channel();
socketChannel.write(echoBuffer);
// 设置接下来关心的事件为read
selectionKey.interestOps(SelectionKey.OP_READ);
echoBuffer.rewind();
}
}
}
// 程序退出前记得关闭selector和ServerSocketChannel，这里演示方便使用了死循环，故不再需要关闭
// selector.close();
// channel.close();
}
}
AIO
AIO全称为Asynchronous IO，是真正的全异步IO。AIO可以实现“调用后不管”，无论IO是否需要等待，操作多久，线程均不会阻塞。等到操作结束时，可以使用专用的线程池，负责处理结果回调。
AIO所有的IO操作均有两个版本：返回Future或者是参数使用CompletionHandler（异步回调）。
例如AsynchronousServerSocketChannel的accept方法的两个版本如下：
public abstract void accept(A attachment,
CompletionHandler handler);
public abstract Future accept();
CompletionHandler的代码如下所示：
public interface CompletionHandler {
/**
* Invoked when an operation has completed.
*
* @param result
* The result of the I/O operation.
* @param attachment
* The object attached to the I/O operation when it was initiated.
*/
void completed(V result, A attachment);
/**
* Invoked when an operation fails.
*
* @param exc
* The exception to indicate why the I/O operation failed
* @param attachment
* The object attached to the I/O operation when it was initiated.
*/
void failed(Throwable exc, A attachment);
}
其中completed在操作成功时候调用，failed在操作失败时候调用。
注意：attachment在调用对应IO操作方法的时候（比如accept）传入。如果IO操作时候需要使用其他对象，将其作为attachment传入是一个很方便的用法。
代码示例
下面代码为AIO 网络通信server和client。
AioServer
public class AioServer {
public static void main(String[] args) throws Exception {
// 创建AsynchronousChannelGroup
// 本质是一个线程池，负责接受异步回调
AsynchronousChannelGroup group = AsynchronousChannelGroup.withThreadPool(Executors.newFixedThreadPool(4));
// 创建通道并绑定地址端口
AsynchronousServerSocketChannel channel = AsynchronousServerSocketChannel.open(group).bind(new InetSocketAddress("127.0.0.1", 9900));
// 接受socket连接，使用异步回调的方式
channel.accept(null, new CompletionHandler() {
@Override
public void completed(AsynchronousSocketChannel result, Object attachment) {
// 在socket连接成功的时候调用
ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
try {
// read方法这里使用返回Future的版本
// 调用future的get方法，阻塞等待数据读取结果
Integer read = result.read(byteBuffer).get();
System.out.println(new String(byteBuffer.array(), 0, read));
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
// 再次调用accept方法，接受下一个socket的连接
// 调用一次accept方法AsynchronousServerSocketChannel仅接受一次请求
channel.accept(null, this);
}
@Override
public void failed(Throwable exc, Object attachment) {
// socket连接失败的时候调用
System.out.println("Accept failed");
}
});
// 阻塞主线程，防止程序退出
CountDownLatch countDownLatch = new CountDownLatch(1);
countDownLatch.await();
}
}
AioClient
public class AioClient {
public static void main(String[] args) throws Exception {
AsynchronousChannelGroup group = AsynchronousChannelGroup.withThreadPool(Executors.newFixedThreadPool(4));
AsynchronousSocketChannel channel = AsynchronousSocketChannel.open(group);
ByteBuffer buffer = ByteBuffer.wrap("Hello from client".getBytes());
// 连接socket服务器，使用异步回调的方式
channel.connect(new InetSocketAddress("127.0.0.1", 9900), null, new CompletionHandler() {
@Override
public void completed(Void result, Object attachment) {
// 异步将buffer的数据写入channel
// 由于不关心什么时候能够写入完毕，我们不处理此方法的返回future
channel.write(buffer);
buffer.rewind();
try {
channel.close();
} catch (IOException e) {
e.printStackTrace();
}
}
@Override
public void failed(Throwable exc, Object attachment) {
System.out.println("Connect failed");
}
});
// 阻塞主线程，防止程序退出
CountDownLatch countDownLatch = new CountDownLatch(1);
countDownLatch.await();
}
}