BIO、NIO、AIO的区别

IO 模型：简单理解为，使用什么样的通道进行数据的发送和同步，很大程度上决定了程序通信的性能

BIO（Blocking I/O）

传统的 Java IO 编程，其相关的类和接口在 java.io 包下。
同步并阻塞（传统阻塞型），服务器实现为一个连接一个线程，即客户端有连接请求时服务端就需要启动一个线程进行处理，如果这个连接不做任何事情就会造成不必要的线程开销，可以通过线程池机制改善
编程简要流程
1. 服务器驱动一个 ServerSocket
2. 客户端启动 Socket 对服务器进行通信，默认情况下服务器短需要对每一个客户端建立一个线程进行通信
3. 客户端发出请求后，先询问服务器是否有线程响应，没有则等待，或者被拒绝
4. 如果有响应，客户端线程会等待请求结束后再继续执行

代码案例

public class Server {

    public static void main(String[] args) throws IOException {
        //创建线程池
        ExecutorService executorService = Executors.newCachedThreadPool();
        //创建serverSocket
        ServerSocket serverSocket = new ServerSocket(6666);
        for (; ; ) {
            System.out.println("等待连接中...");
            //监听,等待客户端连接
            Socket socket = serverSocket.accept();
            System.out.println("连接到一个客户端");
            executorService.execute(() -> handler(socket));
        }
    }

    //编写一个handler方法,和客户端通讯
    public static void handler(Socket socket) {
        byte[] bytes = new byte[1024];
        System.out.println("当前线程信息: " + Thread.currentThread().getName());
        try {
            //通过socket获取输入流
            InputStream inputStream = socket.getInputStream();
            //循环读取客户端发送的数据
            while (inputStream.read(bytes) != -1) {
                System.out.println(Thread.currentThread().getName()+ " : 发送信息为 :"+ new String(bytes, 0, bytes.length));
            }

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            System.out.println("关闭连接");
            try {
                socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

缺陷
- 每个请求都需要创建独立的线程，用于与对应的客户端进行数据处理
- 并发数量大时，需要创建大量线程来处理连接，系统资源占用较大
- 连接建立后，如果当前线程暂时没有数据可读，则当前线程会一直阻塞在 Read 操作上，造成线程资源浪费
传统 IO 模型的网络服务有两种比较经典的设计模式：一种是多线程，一种是依靠线程池进行处理

NIO

NIO 基本介绍

全称 Java non-blocking IO，是从 JDK1.4 开始提供的新 API。相关的类都放在 java.nio 包下，并对 java.io 包中的很多类进行了改写
NIO 三大核心部分：Channel（管道）、Buffer（缓冲区）、Selector（选择器）
同步非阻塞，服务器实现模式为一个线程处理多个请求（连接），即客户端发送的连接请求会被注册到多路复用器上，多路复用器轮询到 I/O 请求就会进行处理
NIO 是面向缓冲区编程的，数据读取到一个它稍微处理的缓冲区，需要时可在缓冲区中前后移动，增加了处理过程的灵活性，使用它可以提供非阻塞的高伸缩性网络
NIO 的非阻塞模式，使一个线程能从某通道发送请求读取数据，但是它仅能得到目前可用数据，如果目前没有可用数据，则不会进行获取，不会保持线程阻塞，直到数据变为可以读取之前，该线程可以响应其他工作，非阻塞写入同理

NIO BUffer 的基本使用

public class BufferTest {

    public static void main(String[] args) {
        //同理对应的还有:ByteBuffer,IntBuffer,FloatBuffer,CharBuffer,ShortBuffer,DoubleBuffer,LongBuffer
        //创建一个Buffer,大小为5
        IntBuffer buffer = IntBuffer.allocate(5);
        //存放数据
        for (int i = 0; i < buffer.capacity(); i++) {
            buffer.put(i);
        }
        //切换成读模式. 读写切换
        buffer.flip();
        while (buffer.hasRemaining()) {
            System.out.println(buffer.get()); // 0 1 2 3 4
        }
    }

}

NIO 和 BIO 的对比
1. BIO 以流的方式处理数据，NIO 以块的方式处理数据，块 I/O 的效率比流 I/O 的效率高很多
2. BIO 是阻塞的，NIO 是非阻塞的
3. BIO 基于字节流和字符流进行操作，而 NIO 基于 Channel 和 Buffer 进行操作，数据总是从通道中读取到缓冲区中，或者从缓冲区写入通道中，Selector 用于监听多个通道时间（比如连接请求、数据到达等），因此使用单个线程就可以监听多个客户端通道

NIO 三大核心组件

组件关系
1. 每个 Channel 对应一个 Buffer
2. Selector 对应一个线程，一个线程对应多个 Channel
3. 程序切换到哪个 Channel 由事件（Event）决定
4. Selector 会根据不同的事件在各个通道上切换
5. Buffer 就是一个内存块，底层有一个数组
6. 数据的读取和写入通过 Buffer，但是需要通过 flip() 切换读写模式，而 BIO 是单向的，要么是输入流，要么是输出流
三个核心理解
- Buffer（缓冲区）
  本质上是一个可以读写数据的内存块，可以理解为一个容器对象（含数组），该对象提供了一组方法可以更轻松的使用内存块，缓冲区对象内置了一些机制，可以跟踪和记录缓冲区的状态变化情况
  Channel 提供从文件、网络读取数据的渠道，但是读取获取写入都必须经过 Buffer
- Channel（管道）
  - NIO 的管道类似于流，但是有以下区别：
    1. 管道是双向的，可以进行读写，流是单向的，只能读或者写
    2. 管道可以实现异步读写数据
    3. 管道可以从缓冲区读取数据，也可以写入数据到缓冲区
  - 常见的 Channel：FileChannel（主要用来对本地文件进行 IO 操作）、DatagramChannel、SocketChannel、SocketServerChannel
- Selector（选择器）
  - 能够检测到多个注册管道上是否有事件发生（多个 Channel 以事件形式注册到同一个 Selector），如果有事件发生，则获取事件并进行相应处理
  - 只有在连接真正有读写事件时才会进行读写，减少系统开销，不用为每个连接都创建一个线程并维护
  - 避免了多线程之间上下文切换导致的开销

NIO 非阻塞网络编程

过程
1. 客户端连接时通过 ServerSocketChannel 得到对应的 SocketChannel
2. Selector 进行监听，调用 select() 方法，返回注册该 Selector 的所有管道中有事件发生的管道个数
3. 将 socketChannel 注册到 Selector 上，一个 Selector 可以注册多个 SocketChannel
4. 注册后返回一个 SelectionKey，和该 Selector 关联（集合形式）
5. 有事件发生时通过 SelectionKey 反向获取 SocketChannel，调用 channel() 方法
6. 通过得到的 channel 完成业务处理

代码示例

Server

public class Server {

    public static void main(String[] args) throws IOException {
        //创建serverSocketChannel
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        //绑定端口
        serverSocketChannel.socket().bind(new InetSocketAddress(6666));
        //设置为非阻塞
        serverSocketChannel.configureBlocking(false);
        //得到Selector对象
        try (Selector selector = Selector.open()) {
            //把ServerSocketChannel注册到selector，事件为OP_ACCEPT
            serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
            //如果返回的>0，表示已经获取到关注的事件
            while (selector.select() > 0) {
                Set<SelectionKey> selectionKeys = selector.selectedKeys();
                Iterator<SelectionKey> iterator = selectionKeys.iterator();
                while (iterator.hasNext()) {
                    //获得到一个事件
                    SelectionKey next = iterator.next();
                    //如果是OP_ACCEPT，表示有新的客户端连接
                    if (next.isAcceptable()) {
                        //给该客户端生成一个SocketChannel
                        SocketChannel accept = serverSocketChannel.accept();
                        accept.configureBlocking(false);
                        //将当前的socketChannel注册到selector，关注事件为读事件，同时给socket Channel关联一个buffer
                        accept.register(selector, SelectionKey.OP_READ,ByteBuffer.allocate(1024));
                        System.out.println("获取到一个客户端连接");
                    //如果是读事件
                    } else if (next.isReadable()) {
                        //通过key 反向获取到对应的channel
                        SocketChannel channel = (SocketChannel) next.channel();
                        //获取到该channel关联的buffer
                        ByteBuffer buffer = (ByteBuffer) next.attachment();
                        while (channel.read(buffer) != -1) {
                            buffer.flip();
                            System.out.println(new String(buffer.array(), 0, buffer.limit()));
                            buffer.clear();
                        }
                    }
                    iterator.remove();
                }
            }
        }
    }

}

Client

public class Client {

    public static void main(String[] args) throws IOException {
        //得到一个网络通道
        SocketChannel socketChannel = SocketChannel.open();
        //设置为非阻塞
        socketChannel.configureBlocking(false);
        //提供服务器端的IP和端口
        InetSocketAddress inetSocketAddress = new InetSocketAddress("127.0.0.1", 6666);
        //连接服务器
        if (!socketChannel.connect(inetSocketAddress)) {
            while (!socketChannel.finishConnect()) {
                System.out.println("连接需要时间,客户端不会阻塞...先去吃个宵夜");
            }
        }
        //连接成功,发送数据
        String str = "hello,Java菜鸟程序员";
        ByteBuffer byteBuffer = ByteBuffer.wrap(str.getBytes());
        socketChannel.write(byteBuffer);
        socketChannel.close();
        System.out.println("客户端退出");
    }

}

AIO（Asynchronous I/O）

JDK7 引入，在进行 I/O 编程中通常用到两种模式：Reactor 和 Proactor，NIO 就是 Reactor 模式，AIO 则是 Proactor 模式
异步非阻塞，AIO 引入异步通道的概念，采用了 ProActor 模式，简化了程序编写，有效的请求才启动线程，特点是先由操作系统完成后才通知服务端程序启动线程去处理，一般适用于连接数较多且连接时间较长的应用
Reactor 基于同步 I/O，Proactor 则和异步 I/O 相关

使用场景

BIO 方式适用于连接数较小且固定的架构，这种方式对服务器资源要求比较高，并发局限于应用中，JDK1.4 之前唯一的选择，程序较为简单且容易理解
NIO 方式适用于连接数多且连接比较短的架构，比如聊天服务器、担幕系统、服务器间通讯等，编程比较复杂，JDK1.4 开始支持
AIO 方式适用于连接数多且连接比较长的架构，比如相册服务器，可以充分调用 OS 参与并发操作，编程比较复杂，JDK7 开始支持

BIO、NIO、AIO的区别

BIO（Blocking I/O）​

NIO​

NIO 基本介绍​

NIO 三大核心组件​

NIO 非阻塞网络编程​

AIO（Asynchronous I/O）​

使用场景​

BIO（Blocking I/O）

NIO

NIO 基本介绍

NIO 三大核心组件

NIO 非阻塞网络编程

AIO（Asynchronous I/O）

使用场景