阻塞、非阻塞、IO多路复用（Selector）网络编程

最新推荐文章于 2024-08-14 21:17:33 发布

一路破防的Java选手

最新推荐文章于 2024-08-14 21:17:33 发布

阅读量1k

点赞数 28

文章标签：网络 java 服务器后端 NIO

本文链接：https://blog.csdn.net/weixin_45863010/article/details/139044939

版权

阻塞

阻塞模式下，相关方法都会导致线程暂停。

ServerSocketChannel.accept 会在没有连接建立时让线程暂停
SocketChannel.read 会在没有数据可读时让线程暂停
阻塞的表现其实就是线程暂停了，暂停期间不会占用 cpu，但线程相当于闲置

单线程模式下，阻塞方法之间相互影响，几乎不能正常工作，需要多线程的支持。然而多线程下，有以下问题。

32 位 jvm 一个线程 320k，64 位 jvm 一个线程 1024k，如果连接数过多，必然导致 OOM，并且线程太多，反而会因为频繁上下文切换导致性能降低
可以采用线程池技术来减少线程数和线程上下文切换，但治标不治本，如果有很多连接建立，但长时间 inactive，会阻塞线程池中所有线程，因此不适合长连接，只适合短连接

使用Java编写示例代码如下：

/**
 * 网络编程，创建服务端
 */
@Slf4j
public class Server {
    public static void main(String[] args) throws IOException {
        // 使用nio来理解阻塞模式，单线程
        // 构建ByteBuffer缓冲区
        ByteBuffer buffer = ByteBuffer.allocate(16);
        // 创建服务器
        ServerSocketChannel ssc = ServerSocketChannel.open();
        // 绑定监听的端口
        ssc.bind(new InetSocketAddress(8080));
        // 创建连接集合
        List<SocketChannel> channels = new ArrayList<>();
        while(true){
            // accept 建立与客户端的连接，SocketChannel用来与客户端之间通信
            log.info("connecting...");
            SocketChannel socketChannel = ssc.accept(); // 阻塞
            log.info("connected ... {}", socketChannel);
            channels.add(socketChannel);
            for (SocketChannel channel : channels) {
                // 接收客户端发送的数据
                log.info("before read ... {}", channel);
                channel.read(buffer);   // 阻塞
                buffer.flip();
                ByteBufferUtil.debugRead(buffer);
                buffer.clear();
                log.info("after read ... {}", channel);
            }
        }
    }
}


public class Client {
    public static void main(String[] args) throws IOException {
        SocketChannel socketChannel = SocketChannel.open();
        socketChannel.connect(new InetSocketAddress(InetAddress.getLocalHost(), 8080));
        System.out.println("waiting ...");
    }
}

非阻塞

非阻塞模式下，相关方法都会不会让线程暂停
- 在 ServerSocketChannel.accept 在没有连接建立时，会返回 null，继续运行
- SocketChannel.read 在没有数据可读时，会返回 0，但线程不必阻塞，可以去执行其它 SocketChannel 的 read 或是去执行 ServerSocketChannel.accept
- 写数据时，线程只是等待数据写入 Channel 即可，无需等 Channel 通过网络把数据发送出去
但非阻塞模式下，即使没有连接建立，和可读数据，线程仍然在不断运行，白白浪费了 cpu
数据复制过程中，线程实际还是阻塞的（AIO 改进的地方）

使用Java编写服务端代码如下：

/**
 * 网络编程，创建服务端
 */
@Slf4j
public class Server {
    public static void main(String[] args) throws IOException {
        // 使用nio来理解非阻塞模式，单线程
        // 构建ByteBuffer缓冲区
        ByteBuffer buffer = ByteBuffer.allocate(16);
        // 创建服务器
        ServerSocketChannel ssc = ServerSocketChannel.open();
        // 将服务器连接设置为非阻塞
        ssc.configureBlocking(false);
        // 绑定监听的端口
        ssc.bind(new InetSocketAddress(8080));
        // 创建连接集合
        List<SocketChannel> channels = new ArrayList<>();
        while(true){
            // accept 建立与客户端的连接，SocketChannel用来与客户端之间通信
//            log.info("connecting...");
            SocketChannel socketChannel = ssc.accept();
            if (socketChannel != null) {
                log.info("connected ... {}", socketChannel);
                socketChannel.configureBlocking(false); // 非阻塞
                channels.add(socketChannel);
            }
            for (SocketChannel channel : channels) {
                // 接收客户端发送的数据
//                log.info("before read ... {}", channel);
                int read = channel.read(buffer);// 阻塞
                if (read > 0) {
                    buffer.flip();
                    ByteBufferUtil.debugRead(buffer);
                    buffer.clear();
                    log.info("after read ... {}", channel);
                }
            }
        }
    }
}

多路复用（Selector）

单线程可以配合 Selector 完成对多个 Channel 可读写事件的监控，这称之为多路复用

多路复用仅针对网络 IO、普通文件 IO 没法利用多路复用
如果不用 Selector 的非阻塞模式，线程大部分时间都在做无用功，而 Selector 能够保证
- 有可连接事件时才去连接
- 有可读事件才去读取
- 有可写事件才去写入
  - 限于网络传输能力，Channel 未必时时可写，一旦 Channel 可写，会触发 Selector 的可写事件

基于Selector实现的多路复用模型如下：

Selector：

Selector（选择器）是 NIO 中的一个关键组件，它允许一个线程处理多个 Channel。Selector 是基于事件驱动的 I/O 多路复用模型，主要运作原理是：通过 Selector 注册通道的事件，Selector 会不断地轮询注册在其上的 Channel。当事件发生时，比如：某个 Channel 上面有新的 TCP 连接接入、读和写事件，这个 Channel 就处于就绪状态，会被 Selector 轮询出来。Selector 会将相关的 Channel 加入到就绪集合中。通过 SelectionKey 可以获取就绪 Channel 的集合，然后对这些就绪的 Channel 进行相应的 I/O 操作。

一个多路复用器 Selector 可以同时轮询多个 Channel，由于 JDK 使用了 epoll() 代替传统的 select 实现，所以它并没有最大连接句柄 1024/2048 的限制。这也就意味着只需要一个线程负责 Selector 的轮询，就可以接入成千上万的客户端。

Selector 可以监听以下四种事件类型：

SelectionKey.OP_ACCEPT：表示通道接受连接的事件，这通常用于 ServerSocketChannel。
SelectionKey.OP_CONNECT：表示通道完成连接的事件，这通常用于 SocketChannel。
SelectionKey.OP_READ：表示通道准备好进行读取的事件，即有数据可读。
SelectionKey.OP_WRITE：表示通道准备好进行写入的事件，即可以写入数据。

Selector是抽象类，可以通过调用此类的 open() 静态方法来创建 Selector 实例。Selector 可以同时监控多个 SelectableChannel 的 IO 状况，是非阻塞 IO 的核心。

所有的 SelectionKey 集合：代表了注册在该 Selector 上的 Channel，这个集合可以通过 keys() 方法返回。
被选择的 SelectionKey 集合：代表了所有可通过 select() 方法获取的、需要进行 IO 处理的 Channel，这个集合可以通过 selectedKeys() 返回。【对于就绪的Channel，通过selectedKeys获取集合后，由于需要将已经处理过的channel从集合中删除，故只能使用迭代器的方式进行遍历，每遍历一个Channel，需要及时调用iterator的remove()方法，将其移除】
被取消的 SelectionKey 集合：代表了所有被取消注册关系的 Channel，在下一次执行 select() 方法时，这些 Channel 对应的 SelectionKey 会被彻底删除，程序通常无须直接访问该集合，也没有暴露访问的方法。
int select()：监控所有注册的 Channel，当它们中间有需要处理的 IO 操作时，该方法返回，并将对应的 SelectionKey 加入被选择的 SelectionKey 集合中，该方法返回这些 Channel 的数量。

使用Java编写Selector服务端代码如下：

/**
 * Selector学习
 */
@Slf4j
public class Server {
    public static void main(String[] args) throws IOException {
        ServerSocketChannel ssc = ServerSocketChannel.open();
        ssc.bind(new InetSocketAddress(8080));
        // 创建Selector
        Selector selector = Selector.open();
        ssc.configureBlocking(false);
        // 注册事件到selector上
        SelectionKey sscKey = ssc.register(selector, 0, null);
        // 设置只关注accept事件
        sscKey.interestOps(SelectionKey.OP_ACCEPT);
        log.debug("sscKey : {}", sscKey);
        while(true){
            // select方法,没有事件发生时,线程阻塞,有事件,线程才会恢复运行
            // select 在事件未处理时,它不会阻塞,事件发生后要么处理,要么取消,不能置之不理
            int count = selector.select();
            log.info("select count : {}", count);
            // 处理事件selectedKeys 内部包含了所有发生的事件
            Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
            while(iterator.hasNext()){
                SelectionKey key = iterator.next();
                log.debug("key : {}", key);
                iterator.remove();
                // 区分事件类型
                if(key.isAcceptable()){
                    // 是连接事件
                    ServerSocketChannel channel = (ServerSocketChannel) key.channel();
                    SocketChannel sc = channel.accept();
                    sc.configureBlocking(false);
                    SelectionKey scKey = sc.register(selector, 0, null);
                    // Key只关注可读事件
                    scKey.interestOps(SelectionKey.OP_READ);
                    log.debug("sc : {}", sc);
                    log.debug("scKey : {}", scKey);
                }else if(key.isReadable()){
                    // 是可读事件
                    try {
                        SocketChannel chanel = (SocketChannel) key.channel();   // 拿到触发事件的channel
                        ByteBuffer buffer = ByteBuffer.allocate(16);
                        int read = chanel.read(buffer);
                        if(read == -1){
                            // 正常断开,read方法的返回值是-1,此时需要将key取消
                            // 正常断开需要走四次挥手,服务端依旧需要读取客户端发送的断开连接的报文,此时依旧会触发一次读事件.
                            key.channel();
                        }else{
                            buffer.flip();
                            ByteBufferUtil.debugRead(buffer);
                        }
                    } catch (IOException e) {
                        e.printStackTrace();
                        // 客户端断开了,因此需要将Key取消(从selector 的 keys集合中真正删除key)
                        key.cancel();
                    }
                }
            }
        }
    }
}

一路破防的Java选手

关注

28
点赞
踩
19

收藏

觉得还不错? 一键收藏
0
评论
阻塞、非阻塞、IO多路复用（Selector）网络编程

Selector 是基于事件驱动的 I/O 多路复用模型，主要运作原理是：通过 Selector 注册通道的事件，Selector 会不断地轮询注册在其上的 Channel。可以采用线程池技术来减少线程数和线程上下文切换，但治标不治本，如果有很多连接建立，但长时间 inactive，会阻塞线程池中所有线程，因此不适合长连接，只适合短连接。32 位 jvm 一个线程 320k，64 位 jvm 一个线程 1024k，如果连接数过多，必然导致 OOM，并且线程太多，反而会因为频繁上下文切换导致性能降低。
复制链接

扫一扫