简述
BIO为同步阻塞BlockingIO，BIO适用于连接数小，结构固定的场景。
NIO为同步非阻塞NoBlockingIO，NIO适用于连接数大，但是任务小的场景。
AIO（NIO.2）为异步非阻塞，AIO适用于连接数大，且时间长的场景。
实际上，主要的分类还是BIO与NIO。
BIO及其经典写法
BIO就是传统IO，用流的方式处理IO。
所有的IO都被视为单个字节的移动，stream对象一次移动一个字节，流IO先把流转换为字节，再转换为对象。
BIO的经典写法如下：
读取输入流的写法
URL url=new URL("http://...");
InputStream is=url.openStream();//获取字节流
InputStreamReader ir=new InputStreamReader(is,"UTF-8");//转为字符流
BufferReader br=new BufferReader(ir);
String data=br.readLine();
while(data!=null){
data=br.readLine();
}
br.close();
ir.close();
is.close();
Socket的客户端写法
Socket socket=new Socket(ip,port);//TCP握手建立连接
OutpurStream os=socket.getOutputStream();//向服务端的输出流
PrintWriter pw=new PrintWriter(os);//包装输出流
pw.write("message");
pw.flush();
socket.shutdownOutput();
//输入流
InputStream is=socket.getInputStream();
BufferReader br=new BufferReader(new InputStreamReader(is));
String data=br.readLine();
while(data!=null){
data=br.readLine();
}
br.close();
is.close();
pw.close();
os.close();
socket.close();
Socket的服务端写法
ServerSocket serverSocket=new ServerSocket(port);
Socket socket=serverSocket.accept();//开始监听，阻塞等待客户端的连接，TCP三次握手后，才能完成
InputStream is=socket.getInputStream();
InputStreamReader isr=new InputStreamReader(is);
BufferReader br=new BufferReader(isr);
String data=br.readLine();
while(data!=null){
data=br.readLine();
}
socket.shutdownInput();
//用输出流向客户端返回信息
OutputStream os=socket.getOutputStream();
PrintWriter pw=new PrintWriter(os);
pw.write("response");
pw.flush();
pw.close();
os.close();
br.close();
isr.close();
is.close();
socket.close();
NIO及其经典写法
NIO不再是流的概念，而是以块的方式处理IO。
不需要一点点地移动字节，这样每个线程只需要处理IO拿到的数据块，不需要等待IO，所以可以复用线程，更可以避免线程切换带来的上下文切换，提升效率。
NIO需要有一个专门的线程处理所有的IO事件，是事件驱动的。
以SocketIO为例，NIO的客户端写法如下：
创建通道和管理器
SocketChannel channel=SocketChannel.open();//通道
channel.configBlocking(false);//非阻塞
this.selector=Selector.open();//通道管理器
channel.connect(new InetSocketAddress(ip,port));//需要通过channel.finishConnect才能完成连接
channel.register(selector,SelectionKey.OP_CONNECT);//通道管理器监听
轮询事件处理
public void listen() throws IOException{
while(true){
Iterator itr=this.selector.selectKeys().iterator();
while(itr.hasNext()){
SelectionKey key=(SelectionKey)itr.next();
itr.remove();
if(key.isConnectable()){
SocketChannel channel=(SelectionKey)key.channel();
if(channel.isConnectionPending){
channel.finishConnect();
}
channel.configBlocking(false);
channel.write(ByteBuffer.wrap(new String("Message content'").getBytes()));
channel.register(this.selector,SelectionKey.OP_READ);
}else if(key.isReadable()){
...
}
}
}
}
NIO的服务端写法如下：
创建通道和管理器
ServerSocketChannel channel=ServerSocketChannel.open();
channel.configBlocking(false);
this.selector=Selector.open();
channel.socket().bind(new InetSocketAddress(port));//server端用bind，client端用connect
channel.register(selector,SelectionKey.OP_ACCEPT);//注册感兴趣的事件
处理事件
public void listen() throws IOException{
while(true){
selector.select();//如果没有感兴趣事件，会一直阻塞
Iterator itr=this.selector.selectKeys().iterator();
while(itr.hasNext()){
SelectionKey key=(SelectionKey)itr.next();
itr.remove();
if(key.isConnectable()){
SocketChannel channel=(SelectionKey)key.channel();
if(channel.isConnectionPending){
channel.finishConnect();
}
channel.configBlocking(false);
channel.write(ByteBuffer.wrap(new String("Message content'").getBytes()));
channel.register(this.selector,SelectionKey.OP_READ);
}else if(key.isReadable()){
...
}
}
}
}
NIO详解
NIO有三个核心对象Buffer、Channel、Selector，其中Channel代替了流，Buffer是流的容器对象，写入Channel需要先经过Buffer，读取Channel也需要先读进Buffer。
Channel是直接读写数据的对象，但它不是流，Channel是双向的（操作系统底层通常都是双向的，所以Channel比流更贴近真实情况），可以异步读写，Channel不允许应用层直接操作。
NIO中的Channel包括：
1.SocketChannel TCP网络IO
2.ServerSocketChannel 监听TCP连接
3.DatagramChannel UDP网络IO
4.FileChannel 文件IO
Buffer是应用层的操作对象，应用层不能直接操作Channel层，只能操作Buffer层，Buffer是个中转池，实质是个数组，能对IO数据结构化访问，而且可以跟踪系统的读写进程。
Buffer的读写功能包括：
1.写入到Buffer
2.从Buffer读出
3.用filp切换读写模式
4.用clear清空buffer
5.用compact压紧，就是清除buffer中已经读过的数据，未读过的数据挪到开头。
Buffer的flip，clear，compact等操作，实质都是设置数组的position、limit和capacity，position代表从哪里开始处理，limit代表处理到哪里，capacity代表容量长度。
Selector是NIO的核心实现，是管理channel通道的对象，每个线程通过1个Selector管理多个Channel对象，Selector注册并监听多个Channel，根据监听事件决定Channel的读写。
使用Selector，首先要打开Selector
Selector selector=Selector.open();
然后要注册到Channel
channel.configueBlocking(false);//设置为异步模式
SelectionKey key=channel.register(selector, SelectionKey.OP_READ | SelectionKey.OP_WRITE);
SelectionKey有OP_CONNECT、OP_ACCEPT、OP_READ、OP_WRITE四种。分别是成功连接，可以接收连接，可以读，可以写。
SelectionKey可以提供Channel和Selector，可以继续附加对象，在selector中监控的所有Channel，都可以通过SelectionKey来间接得到，通过Set<SelectionKey> keys=selector.selectedKeys();可以得到数据集合，通过遍历这个集合，就能检查selector的所有channel。
处理完channel后，我们需要自己手动把selectionKey从数据集中remove挪出来。
epoll
epoll是底层操作系统对NIO的支持机制，epoll用红黑树管理被监控的socket句柄文件，如果socket的读写中断到了，就放进一个准备就绪list链表，仅当链表有数据时，才返回，没有数据就继续等待。
NIO比BIO的优势
BIO是给每个连接分配一个线程，所以在需要大量连接时，就需要大量的线程，线程管理会带来额外开销。
NIO是采用了通知机制等待连接返回数据，只有活动的IO才会占用线程，线程不会被IO阻塞，所以不需要大量的线程，相应的线程创建、销毁、切换等开销也可以省略，资源可以更加集中在业务处理上。NIO适合高并发场景。
BIO的流以字节为单位，一次输入流产生一个字节，一次输出流消费1个自己，缺点是处理速度慢，优点是在字节上为流做过滤器简单方便。
NIO的块以块为单位，每步操作产生或消费一个块，优点是处理速度快，缺点是在块上不能像流一样做简单方便的处理。
BIO和NIO的Socket客户端与服务端写法都不同，BIO客户端是直接Socket socket=new Socket(ip,port)，服务端是先建立ServerSocket serverSocket=new ServerSocket(port)，然后Socket socket=serverSocket.accept();NIO客户端是channel.connect(new InetSocketAddress(ip,port))，服务端是channel.socket.bind(new InetSocketAddress(port));
BIO和NIO在文件处理上的写法
BIO和NIO不仅有网络IO操作，也有文件IO操作，不过文件IO操作不支持异步，无法设置connect.configBlocking(false)。
//BIO文件拷贝
public static void fileCopy(String source, String target) throws IOException {
try (InputStream in = new FileInputStream(source)) {
try (OutputStream out = new FileOutputStream(target)) {
byte[] buffer = new byte[4096];
int bytesToRead;
while((bytesToRead = in.read(buffer)) != -1) {
out.write(buffer, 0, bytesToRead);
}
}
}
}
//NIO文件拷贝
public static void fileCopyNIO(String source, String target) throws IOException {
//声明源文件和目标文件
FileInputStream fi=new FileInputStream(new File(src));
FileOutputStream fo=new FileOutputStream(new File(dst));
//获得传输通道channel
FileChannel inChannel=fi.getChannel();
FileChannel outChannel=fo.getChannel();
//获得容器buffer
ByteBuffer buffer=ByteBuffer.allocate(1024);
while(true){
//判断是否读完文件
int eof =inChannel.read(buffer);
if(eof==-1){
break;
}
//重设一下buffer的position=0，limit=position
buffer.flip();
//开始写
outChannel.write(buffer);
//写完要重置buffer，重设position=0,limit=capacity
buffer.clear();
}
inChannel.close();
outChannel.close();
fi.close();
fo.close();
}
引用
深入浅出NIO Socket实现机制
Java NIO 详解（一）
Java NIO 详解（二）
java IO 流Stream 序列化Serializable 文件File
