1 BIO
可以理解为Blocking IO 是同步阻塞的IO,也就是说,当有多个请求过来的时候,请求会呈现为链状结构,遵循先进先出的原则
1.1 单线程版本
1.1.1 服务端
//服务端单线程处理
public class BioServer {
public static void main(String[] args) throws IOException, InterruptedException {
// 1.创建服务端socket
ServerSocket serverSocket = new ServerSocket(9000);
System.out.println("服务端启动...");
while (true){
System.out.println("服务端接受客户端连接前");
// 2.这里会阻塞
Socket socket = serverSocket.accept();
System.out.println("服务端接受客户端连接后");
// 3.单线程处理方案
handel(socket);
}
}
private static void handel(Socket socket) throws IOException, InterruptedException {
byte[] bytes = new byte[1024];
System.out.println("服务端读取客户端传入信息前" );
// 3.1 read会阻塞 读取客户端数据,要客户端开始写才会向下执行
int read = socket.getInputStream().read(bytes);
if(read != -1){
System.out.println( "服务端读取客户端传入信息,msg:"+new String(bytes,0,read) );
}
System.out.println("服务端向客户端写入信息" );
Thread.sleep(200); //假设写需要200ms
socket.getOutputStream().write("hello client".getBytes());
socket.getOutputStream().flush();
socket.close();
}
}
1.1.2 客户端
package com.ruoyi.weixin.Test.SI_BIO;
import java.io.IOException;
import java.net.Socket;
public class BioClient {
public static void main(String[] args) throws IOException {
for (int i = 0; i < 3; i++) {
new Thread(()->{
try {
connect(Thread.currentThread().getName());
} catch (IOException | InterruptedException e) {
e.printStackTrace();
}
}, "客户端"+i ).start();
}
}
public static void connect(String i) throws IOException, InterruptedException {
String clientname = Thread.currentThread().getName();
// 1.创建连接绑定ip和端口
Socket socket = new Socket("localhost", 9000);
System.out.println(clientname + "开始向服务端写入消息" );
String msg = clientname + "-hello server";
Thread.sleep(300); //假设写需要300ms
socket.getOutputStream().write(msg.getBytes());
socket.getOutputStream().flush();
System.out.println(clientname + "开始向服务端写入消息完成" );
byte[] bytes = new byte[1024];
// 2.read会阻塞 读取客户端数据,要服务端开始写才会向下执行
int read = socket.getInputStream().read(bytes);
// 3.接收服务端回传的数据
System.out.println(clientname + "接收到服务端的数据:" + new String(bytes,0,read) );
socket.close();
}
}
1.1.3 执行
在客户端socket.getOutputStream().write(msg.getBytes());这里打个断点
在服务端socket.getOutputStream().write("hello client".getBytes());打个断点
1)启动服务端
2)启动客户端
客户端控制台,在断点处停住了
服务端控制台,由于客户端在写之前停住了,所以在read()这里阻塞了
客户端放开断点
客户端控制台:
向服务端写完数据后,执行到read,阻塞等待服务端的数据
服务端控制台:
读取完客户端的数据,向下执行
由于断点,在向客户端写之前停住了
放开服务端断点
服务端控制台:
向客户端写完数据,请求处理完成,继续等待下一个请求
客户端控制台,接收服务端数据,请求完成
通过上面的示例,Nio处理请求是一个一个处理的,也就是同步
数据交互read()是阻塞的,需要等待write的执行,也就是阻塞
1.2 多线程版本
上面是一个线程去处理所有请求,现在,一个请求来了,就开一个线程去处理。
优点:把read阻塞给优化了,这里不会阻塞其他线程了,只会在自己的线程里面阻塞,提高了并发能力,提高了效率
缺点:这里有可能会无限制创建线程,线程是稀有资源,如果请求很多,这个时候客户端一直不执行write方法,所有线程就会阻塞在read方法那里,导致线程暴涨,cpu升高,导致机器假死
再优化,采用线程池管理线程去处理请求,可以限制线程数量
public class BioServer {
public static void main(String[] args) throws IOException, InterruptedException {
// 1.创建服务端socket
ServerSocket serverSocket = new ServerSocket(9000);
System.out.println("服务端启动...");
while (true){
System.out.println("服务端接受客户端连接前");
// 2.这里会阻塞
Socket socket = serverSocket.accept();
System.out.println("服务端接受客户端连接后");
// 3.单线程处理方案
new Thread(()->{
try {
handel(socket);
} catch (IOException | InterruptedException e) {
e.printStackTrace();
}
}).start();
}
}
private static void handel(Socket socket) throws IOException, InterruptedException {
byte[] bytes = new byte[1024];
System.out.println("服务端读取客户端传入信息前" );
// 3.1 read会阻塞 读取客户端数据,要客户端开始写才会向下执行
int read = socket.getInputStream().read(bytes);
if(read != -1){
System.out.println( "服务端读取客户端传入信息,msg:"+new String(bytes,0,read) );
}
System.out.println("服务端向客户端写入信息" );
Thread.sleep(200); //假设写需要200ms
socket.getOutputStream().write("hello client".getBytes());
socket.getOutputStream().flush();
socket.close();
}
}
2 NIO
我们上面对BIO进行了一系列的说明,证明了BIO是一个同步的阻塞的IO模型,引出我们NIO,NIO是non-blocking IOjava也称为new IO,是同步非阻塞的IO,下面我们直接上流程图吧
服务端会产生一个ServerSocketChannel,它会注册到selector中,用于服务端和客户端通信使用
client:客户端
客户端会产生一个SocketChannel,它会注册到seletor中,用户服务端和客户端通信使用
buffer:缓冲区
用于客户端和服务端进行数据传输使用,既可以read也可以wirte
channel:通道
包括服务端的ServerSocketChannel和客户端的SocketChannel的通道,它是连接客户端和服务端的通道,是一个双向的既可以读也可以写,都是通过buffer完成的
selector:多路复用器
负责管理channel
selectedKeys:用于获取SocketChannel
2.1 服务端代码
//同步非阻塞 把整个过程分为三部分 建立连接 接收客户端数据(在客户端写之前,不会触发本事件,可以去处理其它的事件) 向客户端发送数据 类似于生产者消费者
public class NioServer {
public static void main(String[] args) throws IOException {
// 打开服务端通道
ServerSocketChannel ssc = ServerSocketChannel.open();
// 设置成非阻塞
ssc.configureBlocking(false);
// 绑定端口
ssc.socket().bind(new InetSocketAddress(9000));
// 打开多路复用器
Selector selector = Selector.open();
// 把ServerSocketChannel注册到selector上,并且selector对客户端accept连接感兴趣
ssc.register(selector, SelectionKey.OP_ACCEPT);
while (true) {
System.out.println("等待事件发生。。");
// 选择多路复用器里面的通道,方法是阻塞的,只有存在客户端进行连接,才可以执行后面逻辑
int select = selector.select();
System.out.println("有事件发生了。。");
// 获取多路复用器里面的所有注册的通道key
Iterator<SelectionKey> it = selector.selectedKeys().iterator();
while (it.hasNext()) {
// 获取某一个通道key
SelectionKey key = it.next();
// 删除当前可以,防止多次处理
it.remove();
handle(key);
}
}
}
private static void handle(SelectionKey key) throws IOException {
// 验证当前通道属于什么事件
if (key.isAcceptable()) { // 连接事件
System.out.println("有客户端连接事件发生了。。");
// 获取当前key所在的通道
ServerSocketChannel ssc = (ServerSocketChannel) key.channel();
// 调用accept()方法获取客户端SocketChannel通道。
//注意这里是阻塞状态的,但是也是非阻塞状态的,这里就是NIO的精髓
//我给大家讲解一下,accept()方法本身是阻塞,它要有客户端连接进来才能向下执行
//前面已经判断是Acceptable()事件,所以一定有客户端进行连接,所以这里就不用等待了
SocketChannel sc = ssc.accept();
// 设置通道为非阻塞方式
sc.configureBlocking(false);
// 将通道注册到多路复用器上,并且注册事件是OP_READ时间
sc.register(key.selector(), SelectionKey.OP_READ);
} else if (key.isReadable()) {
System.out.println("有客户端数据可读事件发生了。。");
SocketChannel sc = (SocketChannel) key.channel();
ByteBuffer buffer = ByteBuffer.allocate(1024);
int len = sc.read(buffer);
if (len != -1){
System.out.println("读取到客户端发送的数据:" + new String(buffer.array(), 0, len));
}
ByteBuffer bufferToWrite = ByteBuffer.wrap("HelloClient".getBytes());
sc.write(bufferToWrite);
key.interestOps(SelectionKey.OP_READ | SelectionKey.OP_WRITE);
} else if (key.isWritable()) {
SocketChannel sc = (SocketChannel) key.channel();
System.out.println("write事件");
key.interestOps(SelectionKey.OP_READ);
}
}
}
2.2 客户端代码
//把整个过程分为三个事件 建立连接 向服务端发送数据 接收服务端数据(在服务端写之前,不会触发本事件,线程就可以去处理其它的事件)
public class NioClient {
private Selector selector;
public static void main(String[] args) throws IOException {
new Thread(()->{
try {
co(Thread.currentThread().getName());
} catch (IOException e) {
e.printStackTrace();
}
}, "客户端1" ).start();
}
public static void co(String clientname ) throws IOException {
NioClient nioClientDemo = new NioClient();
// 初始化客户端
nioClientDemo.initClient("localhost",9000);
// 客户端进行对应操作
nioClientDemo.connect( clientname);
}
/**
* 初始化客户端
* @param ip
* @param port
* @throws IOException
*/
private void initClient(String ip,int port) throws IOException {
// 获取socket通道
SocketChannel socketChannel = SocketChannel.open();
// 配置非阻塞
socketChannel.configureBlocking(false);
// 打开多路复用器
this.selector = Selector.open();
// 连接服务端 其实改方法并没有实现连接,
// 需要在listen()方法中调用channel.finishConnect();才能完成连接
socketChannel.connect(new InetSocketAddress(ip,port));
// 将socket注册到多路复用器,事件为SelectionKey.OP_CONNECT事件
socketChannel.register(selector, SelectionKey.OP_CONNECT);
}
private void connect(String clientname) throws IOException {
while (true){
// 监听多路复用器里面是否存在需要处理的channel 这里是阻塞的
selector.select();
// 获取多路复用器中的channel对应的key
Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
while (iterator.hasNext()){
// 获取SelectionKey
SelectionKey key = iterator.next();
// 获取到之后把当前可以删除,防止重复获取
iterator.remove();
// 验证SelectionKey对应的事件
if(key.isConnectable()){
// 获取通道
SocketChannel channel = (SocketChannel) key.channel();
if(channel.isConnectionPending()){
channel.finishConnect();
}
// 配置成非阻塞方式
channel.configureBlocking(false);
// 写入缓冲流
String msg = clientname + ":Hello server";
ByteBuffer wrap = ByteBuffer.wrap(msg.getBytes());
// 向服务端写入信息
channel.write(wrap);
// 把当前通道注册到多路复用器中,并且注册事件是OP_READ事件
channel.register(selector,SelectionKey.OP_READ);
}else if(key.isReadable()){
read(key);
}else if(key.isWritable()){
System.out.println("客户端开始写事件");
}
}
}
}
/**
* 进行读消息
* @param key
* @throws IOException
*/
private void read(SelectionKey key) throws IOException {
// 获取通道
SocketChannel channel = (SocketChannel) key.channel();
// 设置缓存流一次读取的大小
ByteBuffer buffer = ByteBuffer.allocate(1024);
// 读取消息
int len = channel.read(buffer);//channel.read()不是阻塞的
if(len != -1){
System.out.println("客户端收到消息:" + new String(buffer.array(),0,len)) ;
}
}
}
2.3 执行
为了方便测试,上面客户端代码再复制一份,改一下客户端名称,现在就有两个客户端了
在服务端ByteBuffer bufferToWrite = ByteBuffer.wrap("HelloClient".getBytes());打个断点
在两个客户端的ByteBuffer wrap = ByteBuffer.wrap(msg.getBytes());打个断点
启动服务端
启动客户端1
客户端1:
在断点处停住了
服务端:
注意,此时,服务端在int select = selector.select();处阻塞,等待事件的到来
我们可以启动客户端2来看效果
启动客户端2:
客户端2:
停在断点处
服务端:
发现,服务端处理了客户端2的连接事件
放开客户端1的断点
客户端1:写完后,客户端在selector.select();处阻塞,等待事件的到来
服务端:读取到客户端1的数据,并且在断点处停住了
放开服务端断点
服务端:发送完数据。再次等待下一个事件的到来
客户端1:接收完数据,等待下一个事件(一般来说到这里请求就处理完成了)
放开客户端2的断点:
客户端2:写完后,客户端在selector.select();处阻塞,等待事件的到来
服务端:读取到客户端2的数据,并且在断点处停住了
放开服务端断点
服务端:发送完数据。再次等待下一个事件的到来
服务端:
客户端2:接收完数据,等待下一个事件(一般来说到这里请求就处理完成了)
它的关键是把建立连接,发送数据,接收数据分为三个事件来处理。
这样建立完连接,服务器就空闲下来。等待处理下一个事件。
就算这个请求的客户端在write之前去处理业务需要花费很多时间,也不会阻塞服务端。服务端可以去处理其它请求的事件。所以是非阻塞。
【推荐】国内首个AI IDE,深度理解中文开发场景,立即下载体验Trae
【推荐】编程新体验,更懂你的AI,立即体验豆包MarsCode编程助手
【推荐】抖音旗下AI助手豆包,你的智能百科全书,全免费不限次数
【推荐】轻量又高性能的 SSH 工具 IShell:AI 加持,快人一步
· 全程不用写代码,我用AI程序员写了一个飞机大战
· MongoDB 8.0这个新功能碉堡了,比商业数据库还牛
· 记一次.NET内存居高不下排查解决与启示
· 白话解读 Dapr 1.15:你的「微服务管家」又秀新绝活了
· DeepSeek 开源周回顾「GitHub 热点速览」
2020-12-16 @Slf4j -- lombok.extern.slf4j.Slf4j;
2020-12-16 @mapper注解