IO模型

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

BIO

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

例子：

public class SocketServer {
 
    public static void main(String[] args) throws  Exception {
 
        ServerSocket serverSocket = new ServerSocket(9000);
        while (true){
            System.out.println("等待连接");
            //阻塞连接
            Socket clientSocket = serverSocket.accept();
            System.out.println("有客户端连接。。。");
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        handle(clientSocket);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }
    }
 
    public  static void handle(Socket clientSocket) throws  Exception{
        byte[] bytes = new byte[1024];
        System.out.println("准备read。。");
        //接收客户端的数据，阻塞方法，没有数据可读时就阻塞
        int read = clientSocket.getInputStream().read(bytes);
        System.out.println("read 完毕。");
        if (read !=-1){
            System.out.println("接收到客户端数据：" + new String(bytes,0,read));
        }
        clientSocket.getOutputStream().write("helloClient".getBytes());
        clientSocket.getOutputStream().flush();
    }
}

public class SocketClient {
    public static void main(String[] args) throws IOException {
        Socket socket = new Socket("localhost", 9000);
        //向服务端发送数据
        socket.getOutputStream().write("HelloServer".getBytes());
        socket.getOutputStream().flush();
        System.out.println("向服务端发送数据结束");
        byte[] bytes = new byte[1024];
        //接收服务端回传的数据
        socket.getInputStream().read(bytes);
        System.out.println("接收到服务端的数据：" + new String(bytes));
        socket.close();
    }
}

缺点：

1、IO代码里read操作是阻塞操作，如果连接不做数据读写操作会导致线程阻塞，浪费资源

2、如果线程很多，会导致服务器线程太多，压力太大

应用场景：

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

NIO

Netty, Redis, Nginx底层都是使用的NIO模型。

Non-blocking IO，同步非阻塞，服务器实现模式为一个线程可以处理多个请求(连接)，客户端发送的连接请求都会注册到多路复用器selector上，多路复用

器轮询到连接有IO请求就进行处理，JDK1.4开始引入。

应用场景：

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

NIO 有三大核心组件： Channel(通道)， Buffer(缓冲区)，Selector(多路复用器)

Channel Channel是Java NIO中的一个重要概念，它类似于传统IO中的Stream或FileDescriptor，但提供了更为抽象和灵活的通道模型。Channel可以用于读取、写入和传输数据，它支持阻塞模式和非阻塞模式。在非阻塞模式下，数据读写操作不会阻塞主线程，从而提高了系统的并发性能。channel 类似于流，每个 channel 对应一个 buffer缓冲区，buffer 底层就是个数组，channel 会注册到 selector 上，由 selector 根据 channel 读写事件的发生将其交由某个空闲的线程处理
Buffer Buffer是Java NIO中的一个核心组件，它是一个内存块，用于存储数据的读写。Buffer有一个固定大小的数组作为底层存储，通过使用get()和put()方法来读取和写入数据。Buffer的另一个重要特性是它支持直接内存访问，这意味着可以直接读写内存而无需通过JVM的堆栈。NIO 的 Buffer 和 channel 都是既可以读也可以写
Selector Selector是Java NIO中的一个关键组件，它用于监听多个通道的事件。Selector可以同时监听多个通道的读写事件，并使用select()方法来等待事件的发生。一旦某个通道上有事件发生，Selector就会返回该通道并将其注册到处理事件的线程上。通过使用Selector，可以实现单线程处理多个通道事件的能力，从而提高了系统的并发性能。

NIO底层在JDK1.4版本是用linux的内核函数select()或poll()来实现，跟上面的NioServer代码类似，selector每次都会轮询所有的

sockchannel看下哪个channel有读写事件，有的话就处理，没有就继续遍历，JDK1.5开始引入了epoll基于事件响应机制来优化NIO。

代码例子

public class NioSelectorServer {
 
    public static void main(String[] args) throws Exception {
 
        //创建NIO ServerSocketChannle
        ServerSocketChannel serverSocket = ServerSocketChannel.open();
        serverSocket.bind(new InetSocketAddress(9000));
        //设置ServerSocketChannel为非阻塞
        serverSocket.configureBlocking(false);
        //打开Selector处理channel，即创建epoll
        Selector selector = Selector.open();
        //把ServerSocketChannel注册selector上，并且select对客户端accept连接操作感兴趣
        serverSocket.register(selector, SelectionKey.OP_ACCEPT);
        System.out.println("服务启动");
        //
        while (true) {
            //阻塞等待需要处理的事件发生
            selector.select();
            //获取selector中注册的全部事件的SelectionKey实例
            Set<SelectionKey> selectionKeys = selector.selectedKeys();
            Iterator<SelectionKey> iterator = selectionKeys.iterator();
            //遍历selectionKeys对事件进行处理
            while (iterator.hasNext()) {
                SelectionKey key = iterator.next();
                //如果是accept事件，则进行连接获取和事件注册
                if (key.isAcceptable()) {
                    ServerSocketChannel server = (ServerSocketChannel) key.channel();
                    SocketChannel socketChannel = server.accept();
                    socketChannel.configureBlocking(false);
                    socketChannel.register(selector, SelectionKey.OP_READ);
                    System.out.println("客户端连接成功");
                } else if (key.isReadable()) {
                    //进行数据读取
                    SocketChannel socketChannel = (SocketChannel) key.channel();
                    ByteBuffer byteBuffer = ByteBuffer.allocate(128);
                    int len = socketChannel.read(byteBuffer);
                    // 如果有数据，把数据打印出来
                    if (len > 0) {
                        System.out.println("接收到消息：" + new String(byteBuffer.array()));
                    } else if (len == -1) { // 如果客户端断开连接，关闭Socket
                        System.out.println("客户端断开连接");
                        socketChannel.close();
                    }
                }
                //从事件集合里删除本次处理的key，防止下次select重复处理
                iterator.remove();
            }
        }
    }
}
public class NIOClient {
    public static void main(String[] args) throws Exception {
        //得到一个网络通道
        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("客户端正在尝试连接服务端");
                System.out.println("因为连接需要时间，客户端不会阻塞，可以做其它工作");
            }

        }
        //..如果连接成功，发生数据
        String str = "Hello,world";
        //使用wrap 包裹一个字节数组 字节转成buffer
        ByteBuffer buffer = ByteBuffer.wrap(str.getBytes());
        //发送数据，将来buffer数据写入channel
        socketChannel.write(buffer);
        System.in.read();
    }
}

总结：NIO整个调用流程就是Java调用了操作系统的内核函数来创建Socket，获取到Socket的文件描述符，再创建一个Selector

对象，对应操作系统的Epoll描述符，将获取到的Socket连接的文件描述符的事件绑定到Selector对应的Epoll文件描述符上，进

行事件的异步通知，这样就实现了使用一条线程，并且不需要太多的无效的遍历，将事件处理交给了操作系统内核(操作系统中断

程序实现)，大大提高了效率。

底层原理：

I/O多路复用底层主要用的Linux 内核函数（select，poll，epoll）来实现，windows不支持epoll实现，windows底层是基于winsock2的

select函数实现的(不开源)

AIO

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

应用场景：

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

比较

为什么Netty使用NIO而不是AIO？

在Linux系统上，AIO的底层实现仍使用Epoll，没有很好实现AIO，因此在性能上没有明显的优势，而且被JDK封装了一层不容易深度优

化，Linux上AIO还不够成熟。Netty是异步非阻塞框架，Netty在NIO上做了很多异步的封装。

# IO模型

# BIO

# NIO

# AIO

# 比较

IO模型

BIO

NIO

AIO

比较