Java网络IO模型、阻塞与非阻塞、同步与异步

港控/mmm° 2022-12-19 09:27 214阅读 0赞

# 网络IO模型 #

## 阻塞式I/O ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMjI4MTI4NDk_size_16_color_FFFFFF_t_70_pic_center]

默认情况下，所有的套接字的方法都是阻塞的，如上面的accept、recv。

对应的代码如下：

package com.morris.bio;
    
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.InputStreamReader;
    import java.net.InetSocketAddress;
    import java.net.ServerSocket;
    import java.net.Socket;
    
    public class BioSingleThreadServer { 
    
        public static final int PORT = 8899;
    
        public static void main(String[] args) throws IOException { 
    
            ServerSocket serverSocket = new ServerSocket(); // socket(AF_INET6, SOCK_STREAM, IPPROTO_IP) = 5
    
            serverSocket.bind(new InetSocketAddress(PORT)); // bind(5, {sa_family=AF_INET6, sin6_port=htons(8899), inet_pton(AF_INET6, "::", &sin6_addr), sin6_flowinfo=htonl(0), sin6_scope_id=0}, 28) = 0
            // bind()里面会调用listen方法 listen(5, 50)
    
            System.out.println("server is start at " + PORT); //
    
            while (true) { 
                try { 
                    Socket socket = serverSocket.accept(); // accept(3, {sa_family=AF_INET6, sin6_port=htons(34270), inet_pton(AF_INET6, "::ffff:127.0.0.1", &sin6_addr), sin6_flowinfo=htonl(0), sin6_scope_id=0}, [28]) = 5
                    InputStream inputStream = socket.getInputStream();
                    System.out.println("connect success " + socket.getPort());
    
                    BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
    
                    System.out.println("receive from client: " + reader.readLine()); // recv(5, "hello\r\n", 8192, 0) = 7
    
                    socket.close();
                } catch (Exception e) { 
                    e.printStackTrace();
                }
            }
    
        }
    }

上面的代码需要在jdk1.4上面运行才会出现accept的阻塞，高版本的jdk会使用poll方法阻塞，poll方法返回后才会去调用accept获取连接。

当然使用NIO的阻塞模式也会出现上面的效果，只不过recv函数会缓存read函数。

## 非阻塞式I/O ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMjI4MTI4NDk_size_16_color_FFFFFF_t_70_pic_center 1]

NIO需要调用套接字的方法前，将套接字设置为非阻塞模式，这样调用方法时就不会因为阻塞而进入休眠，而是立即返回，如果没有数据，就会返回一个错误。

对应的代码如下：

package com.morris.nio;
    
    import java.io.IOException;
    import java.net.InetSocketAddress;
    import java.nio.ByteBuffer;
    import java.nio.channels.ServerSocketChannel;
    import java.nio.channels.SocketChannel;
    import java.util.LinkedList;
    import java.util.Objects;
    
    public class NioSingleThreadServer { 
    
        public static final int PORT = 8899;
    
        public static void main(String[] args) throws IOException, InterruptedException { 
    
            ServerSocketChannel serverSocketChannel = ServerSocketChannel.open(); // socket
            serverSocketChannel.bind(new InetSocketAddress(PORT)); // bind+listen
            serverSocketChannel.configureBlocking(false); // 设置accept不阻塞
            LinkedList<SocketChannel> socketChannels = new LinkedList<>(); // 存放所有的客户端连接
    
            while (true) { 
                Thread.sleep(1000);
                // 获取连接
                SocketChannel socketChannel = serverSocketChannel.accept(); // 不阻塞 accept
                if (Objects.isNull(socketChannel)) {  // 没有连接会返回null
                    System.out.println("null");
                } else { 
                    System.out.println("connect success: " + socketChannel.socket().getPort());
                    socketChannel.configureBlocking(false); // 设置read不阻塞
                    socketChannels.add(socketChannel);
                }
    
                // 读取数据
                ByteBuffer byteBuffer = ByteBuffer.allocateDirect(1024);
                for (SocketChannel s : socketChannels) { 
                    if (s.isOpen()) { 
                        int readLength = s.read(byteBuffer); // 不阻塞，没数据返回-1 read
                        if (readLength > 0) { 
                            byteBuffer.flip();
                            byte[] bytes = new byte[byteBuffer.limit()];
                            byteBuffer.get(bytes);
                            System.out.println("receive from client: " + new String(bytes));
                            s.close();
                            byteBuffer.clear();
                        }
                    }
                }
            }
        }
    }

## I/O复用（select/poll/epoll） ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMjI4MTI4NDk_size_16_color_FFFFFF_t_70_pic_center 2]

虽然I/O多路复用的函数也是阻塞的，但是其与以上两种还是有不同的，I/O多路复用是阻塞在select，epoll这样的系统调用之上，而没有阻塞在真正的I/O系统调用如accept之上。

对应的代码如下：

package com.morris.nio;
    
    import java.io.IOException;
    import java.net.InetSocketAddress;
    import java.nio.ByteBuffer;
    import java.nio.channels.SelectionKey;
    import java.nio.channels.Selector;
    import java.nio.channels.ServerSocketChannel;
    import java.nio.channels.SocketChannel;
    import java.util.Iterator;
    import java.util.Set;
    
    public class NioSingleSelectorServer { 
    
        public static final int PORT = 8899;
    
        private static Selector selector;
    
        public static void main(String[] args) throws IOException { 
    
            ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
            serverSocketChannel.bind(new InetSocketAddress(PORT));
            serverSocketChannel.configureBlocking(false);
            selector = Selector.open();
    
            serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT); // 关心接受连接事件
            System.out.println("server is start at " + PORT);
    
            while (true) { 
    
                while (selector.select() > 0) {  // selector.select()不带时间会一直阻塞，可以带一个超时时间
                    Set<SelectionKey> selectionKeys = selector.selectedKeys();
    
                    Iterator<SelectionKey> iterator = selectionKeys.iterator();
                    while (iterator.hasNext()) { 
                        SelectionKey key = iterator.next();
                        iterator.remove();
    
                        if(key.isValid()) { 
                            if(key.isAcceptable()) { 
                                ServerSocketChannel ssc = (ServerSocketChannel) key.channel();
                                // select只会返回有数据的FD，真正获取连接和读取数据还需要调用accept和read
                                SocketChannel socketChannel = ssc.accept();
                                System.out.println("connect success: " + socketChannel.socket().getPort());
                                socketChannel.configureBlocking(false);
                                socketChannel.register(selector, SelectionKey.OP_READ);
                            }
    
                            if(key.isReadable()) { 
                                SocketChannel socketChannel = (SocketChannel) key.channel();
                                ByteBuffer byteBuffer = ByteBuffer.allocateDirect(1024);
                                socketChannel.read(byteBuffer);
    
                                byteBuffer.flip();
    
                                byte[] bytes = new byte[byteBuffer.limit()];
                                byteBuffer.get(bytes);
    
                                System.out.println("receive from client: " + new String(bytes));
                                socketChannel.close();
                            }
                        }
                    }
                }
            }
        }
    }

## 异步I/O ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMjI4MTI4NDk_size_16_color_FFFFFF_t_70_pic_center 3]

异步IO的工作机制是告知内核启动某个操作，并让内核在整个操作（包括将数据从内核拷贝到用户空间）完成后通知我们。

## 总结 ##

阻塞与非阻塞：调用方法能立刻返回就是非阻塞，调用方法要等有数据了才返回就是阻塞。

同步与异步：访问数据的方式，同步需要主动读写数据，在读写数据的过程中还是会阻塞；异步只需要I/O操作完成的通知，并不主动读写数据，由操作系统内核完成数据的读写。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMjI4MTI4NDk_size_16_color_FFFFFF_t_70_pic_center]: /images/20221120/6b4279ea9ba74f479eeaa171632e52be.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMjI4MTI4NDk_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221120/7d2a13d79db4406a84a9d1bdf003ca24.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMjI4MTI4NDk_size_16_color_FFFFFF_t_70_pic_center 2]: https://img-blog.csdnimg.cn/20201106174728207.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMjI4MTI4NDk=,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMjI4MTI4NDk_size_16_color_FFFFFF_t_70_pic_center 3]: https://img-blog.csdnimg.cn/20201106174737874.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMjI4MTI4NDk=,size_16,color_FFFFFF,t_70#pic_center