阻塞

  • 阻塞模式(默认)下，相关方法都会导致线程暂停
    • ServerSocketChannel.accept 会在没有连接建立时让线程暂停
    • SocketChannel.read 会在没有数据可读时让线程暂停
    • 阻塞的表现其实就是线程暂停了，暂停期间不会占用 cpu，但线程相当于闲置
  • 单线程下，阻塞方法之间相互影响，几乎不能正常工作，需要多线程支持
  • 但多线程下，有新的问题，体现在以下方面
    • 32 位 jvm 一个线程 320k，64 位 jvm 一个线程 1024k，如果连接数过多，必然导致 OOM，并且线程太多，反而会因为频繁上下文切换导致性能降低
    • 可以采用线程池技术来减少线程数和线程上下文切换，但治标不治本，如果有很多连接建立，但长时间 inactive，会阻塞线程池中所有线程，因此不适合长连接，只适合短连接 ```java // 使用 nio 来理解阻塞模式, 单线程 // 0. ByteBuffer ByteBuffer buffer = ByteBuffer.allocate(16); // 1. 创建了服务器 ServerSocketChannel ssc = ServerSocketChannel.open();

// 2. 绑定监听端口 ssc.bind(new InetSocketAddress(8080));

// 3. 连接集合 List channels = new ArrayList<>(); while (true) { // 4. accept 建立与客户端连接， SocketChannel 用来与客户端之间通信 log.debug(“connecting…”); SocketChannel sc = ssc.accept(); // 阻塞方法，线程停止运行 log.debug(“connected… {}”, sc); channels.add(sc); for (SocketChannel channel : channels) { // 5. 接收客户端发送的数据 log.debug(“before read… {}”, channel); channel.read(buffer); // 阻塞方法，线程停止运行 buffer.flip(); debugRead(buffer); buffer.clear(); log.debug(“after read…{}”, channel); } }

  1. 客户端
  2. ```java
  3. SocketChannel sc = SocketChannel.open();
  4. sc.connect(new InetSocketAddress("localhost", 8080));
  5. System.out.println("waiting...");

非阻塞

:::tips

  • ssc**.configureBlocking(false**) 会使得 accept() 方法变成 非阻塞

  • sc.configureBlocking(**false**) 会使得read()方法变成非阻塞 :::

  • 非阻塞模式下，相关方法都会不会让线程暂停

    • 在 ServerSocketChannel.**accept 在没有连接建立时，会返回 null，继续运行**
    • SocketChannel.read** 在没有数据可读时，会返回 0**，但线程不必阻塞，可以去执行其它 SocketChannel 的 read 或是去执行 ServerSocketChannel.accept
    • 写数据时，线程只是等待数据写入 Channel 即可，无需等 Channel 通过网络把数据发送出去
  • 但非阻塞模式下，即使没有连接建立，和可读数据，线程仍然在不断运行，白白浪费了 cpu
  • 数据复制过程中，线程实际还是阻塞的（AIO 改进的地方）
    1. // 使用 nio 来理解非阻塞模式, 单线程
    2. // 0. ByteBuffer
    3. ByteBuffer buffer = ByteBuffer.allocate(16);
    4. // 1. 创建了服务器
    5. ServerSocketChannel ssc = ServerSocketChannel.open();
    6. ssc.configureBlocking(false); // 非阻塞模式
    7. // 2. 绑定监听端口
    8. ssc.bind(new InetSocketAddress(8080));
    9. // 3. 连接集合
    10. List<SocketChannel> channels = new ArrayList<>();
    11. while (true) {
    12.   // 4. accept 建立与客户端连接， SocketChannel 用来与客户端之间通信
    13.   SocketChannel sc = ssc.accept(); // 非阻塞，线程还会继续运行，如果没有连接建立，但sc是null
    14.   if (sc != null) {
    15.       log.debug("connected... {}", sc);
    16.       sc.configureBlocking(false); // 非阻塞模式
    17.       channels.add(sc);
    18.   }
    19.   for (SocketChannel channel : channels) {
    20.       // 5. 接收客户端发送的数据
    21.       int read = channel.read(buffer);// 非阻塞，线程仍然会继续运行，如果没有读到数据，read 返回 0
    22.       if (read > 0) {
    23.           buffer.flip();
    24.           debugRead(buffer);
    25.           buffer.clear();
    26.           log.debug("after read...{}", channel);
    27.       }
    28.   }
    29. }

多路复用

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

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