java 的三种IO模型（BIO、NIO、AIO）

BLUcoding2024-10-03 8:22

java 的三种IO模型（BIO、NIO、AIO）

    • [一、BIO 阻塞式 IO（Blocking IO）](#一、BIO 阻塞式 IO（Blocking IO）)
      • [1.1、BIO 工作机制](#1.1、BIO 工作机制)
      • [1.2、BIO 实现单发单收](#1.2、BIO 实现单发单收)
      • [1.3、BIO 实现多发多收](#1.3、BIO 实现多发多收)
      • [1.4、BIO 实现客户端服务端多对一](#1.4、BIO 实现客户端服务端多对一)
      • [1.5、BIO 模式下的端口转发思想](#1.5、BIO 模式下的端口转发思想)
    • [二、NIO 同步非阻塞式 IO（Non-blocking IO）](#二、NIO 同步非阻塞式 IO（Non-blocking IO）)
      • [2.1、NIO 3个核心组件（缓冲区、通道、选择器）](#2.1、NIO 3个核心组件（缓冲区、通道、选择器）)
      • [2.2、NIO 主要特性](#2.2、NIO 主要特性)
      • [2.3、NIO 与 BIO 的对比](#2.3、NIO 与 BIO 的对比)
      • [2.4、Buffer 常用子类](#2.4、Buffer 常用子类)
      • [2.5、Buffer 重要属性](#2.5、Buffer 重要属性)
    • [三、AIO 异步式 IO（Asynchronous IO）](#三、AIO 异步式 IO（Asynchronous IO）)
      • [3.1、AIO 核心组件（异步通道、完成处理器）](#3.1、AIO 核心组件（异步通道、完成处理器）)

一、BIO 阻塞式 IO（Blocking IO）

每个客户端连接都会在一个独立的线程中处理，并且这个线程在处理 IO 操作时会阻塞，直到操作完成。

  • 每个连接都需要一个独立的线程，连接数较多时，会消耗大量的内存和 CPU 资源
  • 线程在处理 IO 操作时会阻塞

1.1、BIO 工作机制

  • 客户端通过 Socket 对象与服务端建立连接，从 Socket 中得到字节输入流或输出流进行数据读写。
  • 服务端通过 ServerSocket 注册端口，调用 accept 方法监听客户端 Socket 请求，从 Socket 中得到字节输入流或输出流进行数据读写。

1.2、BIO 实现单发单收

客户端：

java 复制代码 
public static void main(String[] args) {
	Socket socket = null;
	try {
		//与服务端连接
		socket = new Socket("127.0.0.1", 5000);
		//从 socket 管道中获取字节输出流
		OutputStream os = socket.getOutputStream();
		//将字节输出流包装为打印流
		PrintStream ps = new PrintStream(os);
		//发一行数据
		ps.println("Hi BIO! 与服务端通信成功");
		ps.flush();
	} catch (IOException e) {
		e.printStackTrace();
	}
}

服务端：

java 复制代码 
 public static void main(String[] args) {
 	System.out.println("===服务端启动===");
 	ServerSocket serverSocket = null;
 	try {
 		//注册端口
		serverSocket = new ServerSocket(5000);
		//监听客户端请求
		Socket socket = serverSocket.accept();
		//从 socket 管道中获取字节输入流
		InputStream is = socket.getInputStream();
		//将字节输入流包装为缓冲字符输入流
		BufferedReader br = new BufferedReader(new InputStreamReader(is));
		
		String msg;
		//读一行数据
		if ((msg = br.readLine()) != null) {
			System.out.println("服务端接收客户端信息为：" + msg);
		}
	}catch (Exception e){
		System.out.println(e.getMessage());
	}
}

1.3、BIO 实现多发多收

客户端：

java 复制代码 
public static void main(String[] args) {
    try {
        Socket socket = new Socket("localhost",9988);
        OutputStream os = socket.getOutputStream();
        PrintStream ps = new PrintStream(os);
        Scanner scanner = new Scanner(System.in);
        while (true){
            System.out.println("请输入：");
            String input = scanner.nextLine();
            ps.println(input);
            ps.flush();
        }
     } catch (IOException e) {
     	e.printStackTrace();
     }
}

服务端：

java 复制代码 
public static void main(String[] args) {
    System.out.println("===服务端启动===");
    try {
         ServerSocket ss = new ServerSocket(9988);
         Socket socket = ss.accept();
         InputStream is = socket.getInputStream();
         BufferedReader br = new BufferedReader(new InputStreamReader(is));
         String message;
         while ((message = br.readLine()) != null){
             System.out.println("服务端接收客户端信息为：" + message);
         }
     } catch (IOException e) {
		e.printStackTrace();
     }
}

1.4、BIO 实现客户端服务端多对一

服务端：

java 复制代码 
public void listen() throws IOException {
	ServerSocket serverSocket = null;
	try {
		log.info("服务启动监听");
		serverSocket = new ServerSocket(9988);
		//循环接收到客户端的连接
		while (true) {
			Socket socket = serverSocket.accept();
			//得到连接后，开启一个线程处理连接
			handleSocket(socket);
		}
	} finally {
		if(serverSocket != null){
			serverSocket.close();
		}
	}
}

private void handleSocket(Socket socket) {
	HandleSocket socketHandle = new HandleSocket(socket);
	new Thread(socketHandle).start();
}
java 复制代码 
public void run() {
	BufferedInputStream bufferedInputStream = null;
	BufferedOutputStream bufferedOutputStream  = null;
	try {
		bufferedInputStream = new BufferedInputStream(socket.getInputStream());
		byte[] bytes = new byte[1024];
		int len ;
		if ((len = bufferedInputStream.read(bytes)) > -1) {
			String result = new String(bytes,0,len);
            System.out.println("本次接收到的结果：" + result);
        }
        System.out.println("回复信息给客户端：");
        bufferedOutputStream = new BufferedOutputStream(socket.getOutputStream());
        String outString = Thread.currentThread().getName() + "接收到了";
        bufferedOutputStream.write(outString.getBytes());
        bufferedOutputStream.flush();
	} catch (IOException e) {
		System.out.println("处理异常：" + e.getMessage());
	} finally {
		try {
			if (bufferedInputStream != null) {
				bufferedInputStream.close();
			}
			if (bufferedOutputStream != null) {
				bufferedOutputStream.close();
			}
		}catch (IOException e){
			System.out.println("关闭流异常：" + e.getMessage());
		}
	}
}

客户端：

java 复制代码 
public void start() throws IOException {
	Socket socket = new Socket("127.0.0.1", 8081);
	String msg = "Hi,This is the BioClient";
	BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(socket.getOutputStream());
	byte[] bytes = msg.getBytes();
	bufferedOutputStream.write(bytes);
	bufferedOutputStream.flush();
	System.out.println("发送完毕");
	BufferedInputStream bufferedInputStream = new BufferedInputStream(socket.getInputStream());
	byte[] inBytes = new byte[1024];
	int len;
	if ((len = bufferedInputStream.read(inBytes)) != -1) {
		String result = new String(inBytes, 0, len);
		System.out.println("接收到的消息="+result);
	}
	bufferedOutputStream.close();
	bufferedInputStream.close();
	socket.close();
}

1.5、BIO 模式下的端口转发思想

一个客户端的消息经由服务端发送给所有的客户端，实现群聊功能。

java 复制代码 
public class Server {

    // 定义一个静态集合
    public static List<Socket> allSocketOnLine = new ArrayList();

    public static void main(String[] args) {
        try {
            ServerSocket ss = new ServerSocket(9999);
            while (true){
                Socket socket = ss.accept();
                // 把登录的客户端socket存入到一个在线的集合中去
                allSocketOnLine.add(socket);
                // 为当前登录成功的socket分配一个独立的线程来处理
                new ServerReaderThread(socket).start();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

public class ServerReaderThread extends Thread{

    private Socket socket;
    
    public ServerReaderThread(Socket socket){
        this.socket = socket;
    }
    
    @Override
    public void run() {
        try {
            BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            String msg;
            while ((msg = br.readLine()) != null) {
                // 发送给所有的在线socket
                sendMsgToAllClient(msg);
            }
        } catch (Exception e) {
            System.out.println("有人下线了");
            Server.allSocketOnLine.remove(socket);
        }

    }

    /**
     * 把当前客户端发来的消息发送给全部的在线socket
     * @param msg
     */
    private void sendMsgToAllClient(String msg) throws IOException {
        for (Socket sk : Server.allSocketOnLine) {
            PrintWriter pw = new PrintWriter(sk.getOutputStream());
            pw.println(msg);
            pw.flush();
        }
    }
    
}

二、NIO 同步非阻塞式 IO（Non-blocking IO）

允许线程在等待IO操作完成期间可以继续执行其他任务。

2.1、NIO 3个核心组件（缓冲区、通道、选择器）

缓冲区（Buffer）：用于存储数据的对象。数据从通道读取到缓冲区，或者从缓冲区写入到通道。

通道（Channel）：既可以从通道中读取数据，又可以写数据到通道

选择器（Selector） ：同时管理多个通道，通过注册通道的事件（如连接就绪、读就绪、写就绪），使用单个线程就能处理多个通道，从而管理多个网络连接，提高了效率。

2.2、NIO 主要特性

  • 非阻塞I/O：允许线程在等待IO操作完成期间可以继续执行其他任务
  • IO多路复用：通过选择器，NIO允许多个通道共用一个线程进行管理，减少了线程的资源消耗。
  • 异步IO操作：可以在通道上注册事件和回调函数，实现非阻塞的IO操作
  • 内存映射文件：将文件的一部分或全部直接映射到内存中，这样可以像访问内存一样访问文件，提高了文件处理的效率。
  • 文件锁定：允许对文件的部分或全部进行锁定，从而控制对文件的并发访问。

2.3、NIO 与 BIO 的对比

  • 面向流与面向缓冲：BIO 是面向流的，每次从流中读一个或多个字节，直至读取所有字节；而 NIO 是面向缓冲区的。
  • 阻塞与非阻塞 ：BIO 的流是阻塞的，当一个线程调用 read() 或 write() 时，该线程被阻塞，直到有一些数据被读取或数据完全写入；而 NIO 是非阻塞的，一个线程从某通道发送请求读取数据，它仅能得到目前可用的数据，如果目前没有数据可用时，就什么都不会获取。
  • 线程开销 ：BIO 为每个客户端连接创建一个线程，在大量并发连接的情况下会带来巨大的线程开销；NIO 通过选择器实现 I/O多路复用，在一个线程中处理多个通道，减少了线程开销。

2.4、Buffer 常用子类

  • ByteBuffer：用于存储字节数据；
  • CharBuffer：用于存储字符数据；
  • ShortBuffer：用于存储Short类型数据；
  • IntBuffer：用于存储Int类型数据；
  • LongBuffer：用于存储Long类型数据；
  • FloatBuffer：用于存储Float类型数据；
  • DoubleBuffer：用于存储Double类型数据；

2.5、Buffer 重要属性

  • capacity(容量)：表示 Buffer 所占的内存大小，不能为负且创建后不能更改
  • limit(限制)：表示 Buffer 中可以操作数据的大小，不能为负且不能大于 capacity
    写模式下，表示最多能往 Buffer 里写多少数据，即 limit 等于 capacity
    读模式下，表示最多能读到多少数据，即已写入的所有数据
  • position(位置)：表示下一个要读取或写入的数据的索引
    缓冲区位置不能为负，且不能大于其限制
    初始 position 值为 0，最大为 capacity -- 1。当一个 byte、long 等数据写到 Buffer 后， position 会向前移动到下一个可插入数据的 Buffer 单元
  • mark(标记)：表示记录当前 position 的位置，可通过 reset() 恢复到 mark 的位置

三、AIO 异步式 IO（Asynchronous IO）

异步式IO操作不会阻塞线程，而是交由操作系统处理。完成后，操作系统会通知应用程序，或者应用程序主动查询完成状态。使线程在等待IO完成的同时可以执行其他任务，提高了系统的并发性能。

3.1、AIO 核心组件（异步通道、完成处理器）

  1. 异步通道（Asynchronous Channel） ：AIO 中进行I/O操作的基础设施。

    AIO提供了多种异步通道：
    AsynchronousSocketChannel（异步套接字通道，支持面向连接的网络通信）AsynchronousServerSocketChannel（异步服务器套接字通道，支持异步服务器端套接字通信）AsynchronousFileChannel（异步文件通道，支持异步文件读写操作）

  2. 完成处理器（Completion Handler） ：用于在I/O操作完成后处理结果的回调接口。

    完成处理器包含两个方法：
    completed(V result, A attachment) 在I/O操作成功完成时调用；
    failed(Throwable exc, A attachment) 在I/O操作失败时调用。

相关推荐
菜菜-plus2 分钟前
java 设计模式 模板方法模式
java·设计模式·模板方法模式
萨达大3 分钟前
23种设计模式-模板方法(Template Method)设计模式
java·c++·设计模式·软考·模板方法模式·软件设计师·行为型设计模式
tian-ming5 分钟前
（十八）JavaWeb后端开发案例——会话/yml/过滤器/拦截器
java·开发语言·前端
不能只会打代码8 分钟前
大学课程项目中的记忆深刻 Bug —— 一次意外的数组越界
java·github·intellij-idea·话题博客
快意咖啡~14 分钟前
java.nio.charset.MalformedInputException: Input length = 1
java·开发语言·nio
IT枫斗者41 分钟前
如何解决Java EasyExcel 导出报内存溢出
java·服务器·开发语言·网络·分布式·物联网
爱编程的小生43 分钟前
Easyexcel（4-模板文件）
java·excel
求积分不加C1 小时前
Kafka怎么发送JAVA对象并在消费者端解析出JAVA对象--示例
java·分布式·kafka·linq
2401_857636391 小时前
实验室管理平台：Spring Boot技术构建
java·spring boot·后端
问窗1 小时前
微服务中Spring boot的包扫描范围
java·spring boot·微服务
热门推荐
01(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明02PyTorch机器学习实现液态神经网络03【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总04玄机平台应急响应—webshell查杀05Coze扣子平台完整体验和实践（附国内和国际版对比）06RAG 实践- Ollama+RagFlow 部署本地知识库0704 - matlab m_map地学绘图工具基础函数 - 设置网格08Unity中PICO实现 隔空取物 和 接触抓取物体09Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO10【目标跟踪】相机运动补偿