阻塞
阻塞模式下,相关方法都会导致线程暂停。
-
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();
}
}
}
}
}
}