NIO和IO多路复用

浅浅的花香味﹌ 2023-06-16 08:03 25阅读 0赞

# NIO的引入 #

使用BIO进行socket通信时，**accept连接** 和 **read读** 均会阻塞。

这样就会出现以下问题：

1. 第一个客户端建立连接后，但是不发送数据，server会释放cpu资源，并且等待客户端发送数据

2. 第二个客户端无法建立连接

编写一个BIOServer

public class BIOServer {
        public static void main(String[] args) throws IOException {
            byte[] bytes = new byte[1024];
            ServerSocket serverSocket = new ServerSocket();
    
            // 端口号+ip，ip默认本机
            serverSocket.bind(new InetSocketAddress(9876));
    
            // 阻塞--程序释放cpu资源，程序不会向下执行
            // accept，专门负责通信
            while (true) {
                System.out.println("--等待连接--");
                Socket accept = serverSocket.accept();
                System.out.println("--连接成功--");
    
                // 解阻塞，向下执行，read也会阻塞
                System.out.println("--开始读数据--");
                int read = accept.getInputStream().read(bytes);
                System.out.println("--数据读取完成：" + read + "--");
    
                // 字节数组转string
                String content = new String(bytes);
                System.out.println(content);
    
                // 回复，写，略
            }
        }
    }

再创建一个客户端

public class Client {
        public static void main(String[] args) throws IOException {
            Socket socket = new Socket();
            socket.connect(new InetSocketAddress("127.0.0.1", 9876));
    
            System.out.println("--请输入内容--");
            Scanner scanner = new Scanner(System.in);
            while (true) {
                String next = scanner.next();
                socket.getOutputStream().write(next.getBytes());
            }
        }
    }

运行BIOServer 和client，便会出现以下结果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTQxNjE5_size_16_color_FFFFFF_t_70][]

总结：

1. 如果采用单线程，无法处理并发

2. 解决？ 引入多线程

# 多线程实现socket通信 #

client不变，新建一个BioServerBatch类，子线程自己阻塞

public class BioServerBatch {
        public static void main(String[] args) throws IOException {
            ServerSocket serverSocket = new ServerSocket();
            serverSocket.bind(new InetSocketAddress(9876));
    
            while (true) {
                System.out.println("--等待连接--");
                Socket socket = serverSocket.accept();
                System.out.println("--连接成功--");
    
                Thread thread = new Thread(new ExecuteSocket(socket));
                thread.start();
            }
        }
    
        static class ExecuteSocket implements Runnable {
            private Socket socket;
            private byte[] bytes = new byte[1024];
    
            // 处理每个客户端连接 -- 读写
            ExecuteSocket(Socket socket) {
                this.socket = socket;
            }
    
            @Override
            public void run() {
                try {
                    System.out.println("--开始读数据--");
    
                    socket.getInputStream().read(bytes);
                    String content = new String(bytes);
    
                    System.out.println("--数据读取完成：" + content + "--");
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

这样就可以实现并发通信，但是存在一个问题，比如开100个线程，真正发生读写的线程只有20%有效，80%的线程存在浪费现象，对服务器损耗很大。

解决？单线程实现高并发

# 单线程解决高并发 NIO #

实现机制：

不让程序阻塞

1.  等待连接和读数据不阻塞
2.  有人来连，设置为非阻塞读，将当前socket放入到list，遍历list，查看是否有人发数据
3.  没人来连，将当前socket放入到list，遍历list，查看是否有人发数据

Java为我们提供了API来实现该机制，代码如下：

public class NIOServer {
        public static void main(String[] args) throws IOException, InterruptedException {
            ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
            List<SocketChannel> list = new ArrayList<>();
            ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
    
            serverSocketChannel.bind(new InetSocketAddress(9876));
    
            // 设置为非阻塞
            serverSocketChannel.configureBlocking(false);
    
            while (true) {
                Selector selector = Selector.open();
                SocketChannel socketChannel = serverSocketChannel.accept();
                if (socketChannel == null) {
                    System.out.println("--没人连接--");
                    Thread.sleep(1000);
                    for (SocketChannel channel : list) {
                        int k =  channel.read(byteBuffer);
                        System.out.println(k);
    
                        if (k != 0) {
                            // 有人发数据
                            byteBuffer.flip();
                            System.out.println("========no conn=======》" + new String(byteBuffer.array()));
                        }
                    }
                } else {
                    System.out.println("--有人连接--");
                    socketChannel.configureBlocking(false);
                    list.add(socketChannel);
    
                    // 得到套接字，循环所以的套接字，通过套接字获取数据
                    for (SocketChannel channel : list) {
                        int k = channel.read(byteBuffer);
                        if (k != 0) {
                            byteBuffer.flip();
                            System.out.println("========conn=======》" + new String(byteBuffer.array()));
                        }
                    }
                }
            }
        }
    }

但该程序依然存在以下问题：

每次循环的时候，都会遍历list列表，如果列表很大，且只有20%有读写，性能还是较低

解决？IO多路复用

# IO多路复用 #

将list交给操作系统来处理

具体的方法有三个：select、poll和epoll，有兴趣的可以去了解一下

应用：redis、nginx和java nio在linux上的实现

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTQxNjE5_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20191125140120346.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTQxNjE5,size_16,color_FFFFFF,t_70