netty(一)：一文搞懂BIO、NIO、AIO

IO模型就是说用什么样的通道进行数据的发送和接收，Java共支持3种网络编程IO模式：BIO，NIO，AIO.

一、BIO(Blocking IO)

同步阻塞模型，一个客户端连接对应一个处理线程

1、缺点

1、IO代码里read操作是阻塞操作，如果连接不做数据读写操作会导致线程阻塞，浪费资源
2、如果线程很多，会导致服务器线程太多，压力太大。

2、应用场景

BIO 方式适用于连接数目比较小且固定的架构，这种方式对服务器资源要求比较高，但程序简单易理解。

3、BIO代码示例

服务端

public class BIOServer {
    public static void main(String[] args) {
        try {
            ServerSocket serverSocket = new ServerSocket(9090);
            while(true) {
                //阻塞调用
                System.out.println("阻塞调用，监听客户端的请求");
                Socket socket = serverSocket.accept();
                System.out.println("有客户端进来...");
                //handler(socket);
                new Thread(()->{
                    try {
                        handler(socket);
                    } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }).start();
                /**
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        handler(socket);
                    }
                }).start();
                **/
            }
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    private static void handler(Socket socket) throws IOException {
        System.out.println("thread id = "+Thread.currentThread().getId());
        byte[] bytes = new byte[1024];
        System.out.println("准备read。。。");
        //接收客户端的数据，阻塞方法，没有数据可读时就阻塞
        System.out.println("阻塞调用，监听客户端发送消息事件");
        int read =socket.getInputStream().read(bytes);
        System.out.println("read 完毕。。。");
        if(read!=-1) {
            System.out.println("接受服务器的数据："+new String(bytes,0,read));
            System.out.println("thread id = "+Thread.currentThread().getId());
        }
        socket.getOutputStream().write("客户端您好，我是大佬".getBytes());
        socket.getOutputStream().flush();
    }
}

客户端

public class BIOClient {
    public static void main(String[] args) throws UnknownHostException, IOException {
        Socket socket = new Socket("localhost",9090);
        //向服务端发数据
        socket.getOutputStream().write("您好服务器，我是客户端".getBytes());
        socket.getOutputStream().flush();
        System.out.println("向服务器发送数据结束");
        byte[] bytes = new byte[1024];
        //阻塞调用，等待服务端发数据
        int read =socket.getInputStream().read(bytes);
        System.out.println("read 完毕。。。");
        if(read!=-1) {
            System.out.println("接受客户端的数据："+new String(bytes,0,read));
            System.out.println("thread id = "+Thread.currentThread().getId());
        }
    }
}

BIO是阻塞调用的，服务端阻塞体现在下面两段代码逻辑：

//这里会阻塞监听客户端的请求
Socket socket = serverSocket.accept();

//阻塞调用，监听客户端发送消息事件
int read =socket.getInputStream().read(bytes);

客户端的阻塞体现在如下代码逻辑：

//阻塞调用，等待服务端发数据
int read =socket.getInputStream().read(bytes);

二、NIO(Non Blocking IO)

同步非阻塞，服务器实现模式为一个线程可以处理多个请求(连接)，客户端发送的连接请求都会注册到多路复用器selector上，多路复用器轮询到连接有IO请求就进行处理。
I/O多路复用底层一般用的Linux API（select，poll，epoll）来实现，他们的区别如下表：

1、应用场景

NIO方式适用于连接数目多且连接比较短（轻操作）的架构，比如聊天服务器，弹幕系统，服务器间通讯，编程比较复杂， JDK1.4 开始支持。

NIO 有三大核心组件： Channel(通道)， Buffer(缓冲区)，Selector(选择器)

下面是我之前写的三篇博文，可以参考下。

一、实战-缓冲区Buffer(NIO)
二、实战-通道（Channel）(NIO)
实战：Selector选择器(NIO)

1、channel 类似于流，每个 channel 对应一个 buffer缓冲区，buffer 底层就是个数组
2、channel 会注册到 selector 上，由 selector 根据 channel 读写事件的发生将其交由某个空闲的线程处理
3、selector 可以对应一个或多个线程
4、NIO 的 Buffer 和 channel 都是既可以读也可以写

2、NIO代码示例

服务端

public class NIOServer {
    public static void main(String[] args) throws IOException {
        //创建一个在本地端口进行监听的服务Socket通道，并设置为非阻塞方式
        ServerSocketChannel ssc = ServerSocketChannel.open();
        //必须配置为非阻塞才能往selector上注册，否则会报错，selector模式本身就是非阻塞模式
        ssc.configureBlocking(false);
        ssc.socket().bind(new InetSocketAddress(9090));
        //创建一个选择器selector
        Selector selector = Selector.open();
        //把ServerSocketChannel注册到selector上，并且slector对客户端accept连接操作感兴趣
        ssc.register(selector, SelectionKey.OP_ACCEPT);
        //此时selector里面有一个channel了
        while(true) {
            System.out.println("等待事件发生。。");
            //轮询监听channel里的key，select是阻塞的，accept()也是阻塞的
            int select = selector.select();
            System.out.println("有事件发生了");
            //有客户端请求，轮询监听到
            Iterator<SelectionKey> it = selector.selectedKeys().iterator();
            while (it.hasNext()) {
                SelectionKey key = it.next();
                //删除本次已处理的key，防止下次select重复处理
                it.remove();
                handle(key);
            }
        }
    }
    private static void handle(SelectionKey key) throws IOException {
        if(key.isAcceptable()) {
            System.out.println("有客户端连接事件发生了");
            ServerSocketChannel  ssc = (ServerSocketChannel)key.channel();
            //NIO非阻塞体现：此处accept方法是阻塞的，但是这里因为发生了连接事件，所以这个方法会
            //马上执行，不会阻塞
            //处理完连接请不会继续等待客户端的数据发送
            SocketChannel sc = ssc.accept();
            //也要设置成非阻塞模式，然后跟ServerSocketChannel一样，放进Selector中去
            sc.configureBlocking(false);
            //通过Selector监听Channel时对读事件感兴趣
            //因为对于服务端，channel是读数据进来：channel既可以写，也可以读，跟流不一样
            sc.register(key.selector(), SelectionKey.OP_READ);
            //此时selector里面有两个channel了，一个ServerSocketChannel，一个SocketChannel
            //后面每多一个连接就多一个channel
        }else if(key.isReadable()) {
            //有客户端数据可读事件发生了。。
            SocketChannel  sc = (SocketChannel)key.channel();
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            //NIO非阻塞体现：首先read方法不会阻塞，其次这种事件响应模型，当调用到read方法时肯定时发生了客户端发送数据的事件
            int len =sc.read(buffer);
            if(len!=-1) {
                System.out.println("读取客户端发送的数据："+new String(buffer.array(),0,len));
            }
            ByteBuffer bufferToWrite = ByteBuffer.wrap("您好，客户端，我是大佬".getBytes());
            sc.write(bufferToWrite);
            //对该channel设置对读和写事件的兴趣
            key.interestOps(SelectionKey.OP_READ|SelectionKey.OP_WRITE);
        }else if(key.isWritable()) {
            System.out.println("write事件");
            //NIO事件触发是水平触发的
            //使用Java的NIO编程的时候，在没有数据可以往外写的时候要取消写事件
            //在有数据往外写的时候再注册写事件
            key.interestOps(SelectionKey.OP_READ);
        }
    }
}

客户端

public class NIOClient {
    public static void main(String[] args) throws IOException {
        //获得一个Socket通道
        SocketChannel channel = SocketChannel.open();
        //设置通道为非阻塞
        channel.configureBlocking(false);
        //客户端连接服务器，其实方法执行并没有实现连接，需要listen()方法中
        //调用channel.finishConnect()；才能完成连接
        channel.connect(new InetSocketAddress("127.0.0.1",9090));
        //获得一个通道选择器
        Selector selector = Selector.open();
        channel.register(selector, SelectionKey.OP_CONNECT);
        //采用轮询的方式监听selector上是否有需要处理的事件，如果有，则进行处理
        while(true) {
            selector.select();
            System.out.println("有事件发生了");
            //有客户端请求，轮询监听到
            Iterator<SelectionKey> it = selector.selectedKeys().iterator();
            while (it.hasNext()) {
                SelectionKey key = it.next();
                //删除本次已处理的key，防止下次select重复处理
                it.remove();
                handle(key);
            }
        }
    }
    private static void handle(SelectionKey key) throws IOException {
        if(key.isConnectable()) {
            System.out.println("有连接事件发生了");
            SocketChannel  sc = (SocketChannel)key.channel();
            //如果正在连接，则完成连接
            if(sc.isConnectionPending()) {
                sc.finishConnect();
            }
            //设置成非阻塞
            sc.configureBlocking(false);
            //再这里可以给服务端发送信息
            ByteBuffer bufferToWrite = ByteBuffer.wrap("您好，服务端，我是客户端".getBytes());
            sc.write(bufferToWrite);
            //再和服务端连接成功之后，为了可以接收到服务端的信息，
            //需要给通道设置读的权限
            key.interestOps(SelectionKey.OP_READ);
        }else if(key.isReadable()) {
            //有客户端数据可读事件发生了。。
            SocketChannel  sc = (SocketChannel)key.channel();
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            //NIO非阻塞体现：首先read方法不会阻塞，其次这种事件响应模型，当调用到read方法时肯定时发生了客户端发送数据的事件
            int len =sc.read(buffer);
            if(len!=-1) {
                System.out.println("客户端收到信息："+new String(buffer.array(),0,len));
            }
        }
    }
}

NIO服务端程序详细分析：

1、创建一个 ServerSocketChannel 和 Selector ，并将 ServerSocketChannel 注册到 Selector 上
2、 selector 通过 select() 方法监听 channel 事件，当客户端连接时，selector 监听到连接事件，获取到 ServerSocketChannel 注册时
绑定的 selectionKey
3、selectionKey 通过 channel() 方法可以获取绑定的 ServerSocketChannel
4、ServerSocketChannel 通过 accept() 方法得到 SocketChannel
5、将 SocketChannel 注册到 Selector 上，关心 read 事件
6、注册后返回一个 SelectionKey, 会和该 SocketChannel 关联
7、selector 继续通过 select() 方法监听事件，当客户端发送数据给服务端，selector 监听到read事件，获取到 SocketChannel 注册时
绑定的 selectionKey
8、selectionKey 通过 channel() 方法可以获取绑定的 socketChannel
9、将 socketChannel 里的数据读取出来
10、用 socketChannel 将服务端数据写回客户端

总结：NIO模型的selector 就像一个大总管，负责监听各种IO事件，然后转交给后端线程去处理

NIO相对于BIO非阻塞的体现:

BIO的后端线程需要阻塞等待客户端写数据(比如read方法)，如果客户端不写数据，线程就要阻塞，NIO把等待客户端操作的事情交给了大总管 selector，selector 负责轮询所有已注册的客户端，发现有事件发生了才转交给后端线程处理，后端线程不需要做任何阻塞等待，直接处理客户端事件的数据即可，处理完马上结束，或返回线程池供其他客户端事件继续使用。还有就是 channel 的读写是非阻塞的。

Redis就是典型的NIO线程模型，selector收集所有连接的事件并且转交给后端线程，线程连续执行所有事件命令并将结果写回客户端.

不管是ServerSocketChannel还是SocketChannel都是扔进selector管理，其实一个channel可以看作是直连客户端和服务端并且两边都可以读写数据。

三、AIO(NIO 2.0)

异步非阻塞，由操作系统完成后回调通知服务端程序启动线程去处理，一般适用于连接数较多且连接时间较长的应用。

1、应用场景

AIO方式适用于连接数目多且连接比较长（重操作）的架构，JDK7 开始支持

2、代码示例

服务端

public class AIOServer {
    public static void main(String[] args) throws IOException, InterruptedException {
        AsynchronousServerSocketChannel serverChannel = 
                AsynchronousServerSocketChannel.open().
                bind(new InetSocketAddress(9090));
        serverChannel.accept(null, new CompletionHandler<AsynchronousSocketChannel, Object>() {
            //异步回调
            @Override
            public void completed(AsynchronousSocketChannel socketChannel, Object attachment) {
                //再此接收客户端连接，如果不写这行代码后面的客户端连接不上服务器端
                try {
                    serverChannel.accept(attachment, this);
                    System.out.println(socketChannel.getRemoteAddress());
                    ByteBuffer buffer = ByteBuffer.allocate(024);
                    socketChannel.read(buffer, buffer, new CompletionHandler<Integer, ByteBuffer>() {
                        //异步回调
                        @Override
                        public void completed(Integer result, ByteBuffer attachment) {
                            buffer.flip();
                            System.out.println(new String(buffer.array(),0,result));
                            socketChannel.write(ByteBuffer.wrap("您好，客户端，我是大佬".getBytes()));
                        }
                        @Override
                        public void failed(Throwable exc, ByteBuffer attachment) {
                            exc.printStackTrace();
                        }
                    });
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            @Override
            public void failed(Throwable exc, Object attachment) {
                exc.printStackTrace();
            }
        });
        System.out.println("arrive down。。。");
        //因为AIO是异步非阻塞的，所以这里必须设置等待
        Thread.sleep(Integer.MAX_VALUE);
    }
}

客户端

public class AIOClient {
    public static void main(String[] args) throws IOException, InterruptedException, ExecutionException {
        AsynchronousSocketChannel socketChannel = AsynchronousSocketChannel.open();
        socketChannel.connect(new InetSocketAddress("127.0.0.1",9090)).get();
        //发送数据到服务端
        socketChannel.write(ByteBuffer.wrap("服务端您好，我是客户端".getBytes()));
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        Integer len = socketChannel.read(buffer).get();
        if(len!=-1) {
            System.out.println("客户端收到信息："+new String(buffer.array(),0,len));
        }
    }
}

AIO的accept和read方法都通过回调来实现异步，其实AIO是对NIO进行了封装，当然后续要研究的netty也是对NIO的封装，毕竟直接NIO代码太容易出错了。

一、BIO(Blocking IO)

1、缺点

2、应用场景

3、BIO代码示例

二、NIO(Non Blocking IO)

1、应用场景

2、NIO代码示例

三、AIO(NIO 2.0)

1、应用场景

2、代码示例

四、BIO、 NIO、 AIO 对比