常见的IO

# Java中常见的IO模型

Java主要有以下几种IO模型：

IO模型名称	特点描述	适用场景
阻塞IO（Blocking IO）	线程发起IO调用后，如果数据没准备好，就阻塞等待，线程被挂起。	简单应用，线程数少的场景
非阻塞IO（Non-blocking IO）	线程发起IO调用后，不等待数据准备，立即返回，通过轮询检查数据是否准备好。	高并发，要求线程数较少
IO复用（Multiplexing IO）	多路复用IO，使用操作系统的`select`/`poll`/`epoll`等机制，让单个线程监听多个IO通道。	大量连接场景，提升单线程处理能力
异步IO（Asynchronous IO）	IO调用发起后，操作系统完成IO后通过回调通知程序，线程不用等待。	高性能服务器，需极致响应速度和资源利用率

# 1. 阻塞IO（BIO，Blocking IO）

调用read()或write()时，线程被阻塞直到完成操作或出错。
一个连接对应一个线程，处理该连接的所有读写操作。
线程资源消耗较大，性能瓶颈明显。
Java中最基础的IO模型，基于java.io包的流。

示意图：

线程A: 读取数据 -> 阻塞等待 -> 数据到达 -> 处理数据
线程B: 读取数据 -> 阻塞等待 -> 数据到达 -> 处理数据
...

1
2
3

适用场景：

连接数少，业务简单
实现简单易懂

# 2. 非阻塞IO（NIO中的非阻塞模式）

线程发起读写调用时，调用立即返回，不会阻塞线程。
需要不断轮询（polling）IO通道，检查是否有数据准备好。
线程资源利用较好，但需要额外的轮询控制代码。

Java中通过java.nio.channels.SocketChannel可以设置非阻塞模式：

SocketChannel channel = SocketChannel.open();
channel.configureBlocking(false);

1
2

# 3. IO复用（Multiplexing IO）

线程调用操作系统提供的select或poll方法监听多个通道（socket）。
只要有任一通道准备好读写，线程就被唤醒，处理对应的IO事件。
这样一个线程可以管理大量连接，大幅提升资源利用率。
Java的NIO库中提供了Selector类实现IO复用。

# 4. 异步IO（AIO）

IO操作完全由操作系统异步执行，完成后通过回调函数通知Java程序。
线程无需阻塞等待，线程资源效率最高。
Java 7引入了java.nio.channels.AsynchronousSocketChannel支持AIO。

# Java IO模型演变与对应技术

模型	Java API示例	说明
阻塞IO	java.io.*	经典IO，流式，线程阻塞
非阻塞IO	java.nio.channels.SocketChannel	轮询，非阻塞，低层次控制
IO复用	java.nio.channels.Selector	复用多路IO事件，单线程管理多连接
异步IO	java.nio.channels.AsynchronousSocketChannel	完全异步，基于回调

# 简单示例对比：阻塞IO与NIO中的非阻塞IO

# 1. 阻塞IO的Socket示例（Server端）

import java.io.*;
import java.net.*;

public class BlockingIOServer {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(9000);
        System.out.println("阻塞IO服务器启动，监听端口9000");

        while (true) {
            Socket clientSocket = serverSocket.accept();  // 阻塞，等待连接
            System.out.println("客户端连接：" + clientSocket.getRemoteSocketAddress());

            BufferedReader reader = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
            String line;
            while ((line = reader.readLine()) != null) {  // 阻塞等待数据
                System.out.println("收到数据: " + line);
                if ("exit".equalsIgnoreCase(line)) {
                    break;
                }
            }
            clientSocket.close();
            System.out.println("客户端断开连接");
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

# 2. NIO非阻塞模式示例（Server端）

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;

import java.util.Iterator;
import java.util.Set;

public class NonBlockingIOServer {
    public static void main(String[] args) throws IOException {
        Selector selector = Selector.open();

        ServerSocketChannel serverChannel = ServerSocketChannel.open();
        serverChannel.configureBlocking(false);  // 非阻塞模式
        serverChannel.bind(new InetSocketAddress(9000));
        serverChannel.register(selector, SelectionKey.OP_ACCEPT);

        System.out.println("非阻塞IO服务器启动，监听端口9000");

        while (true) {
            int readyChannels = selector.select();  // 阻塞直到有事件发生
            if (readyChannels == 0) continue;

            Set<SelectionKey> selectedKeys = selector.selectedKeys();
            Iterator<SelectionKey> keyIterator = selectedKeys.iterator();

            while (keyIterator.hasNext()) {
                SelectionKey key = keyIterator.next();

                if (key.isAcceptable()) {
                    ServerSocketChannel server = (ServerSocketChannel) key.channel();
                    SocketChannel client = server.accept();
                    client.configureBlocking(false);
                    client.register(selector, SelectionKey.OP_READ);
                    System.out.println("客户端连接：" + client.getRemoteAddress());
                }

                else if (key.isReadable()) {
                    SocketChannel client = (SocketChannel) key.channel();
                    ByteBuffer buffer = ByteBuffer.allocate(1024);
                    int bytesRead = client.read(buffer);
                    if (bytesRead > 0) {
                        buffer.flip();
                        byte[] data = new byte[buffer.limit()];
                        buffer.get(data);
                        String msg = new String(data);
                        System.out.println("收到数据：" + msg);
                    } else if (bytesRead == -1) {
                        client.close();
                        System.out.println("客户端断开连接");
                    }
                }

                keyIterator.remove();
            }
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

# 总结

阻塞IO（BIO） 简单直观，线程资源消耗大，适合少量连接。
非阻塞IO（NIO） 线程不阻塞，需轮询检查，适合中等并发。
IO复用 用Selector实现一个线程管理多个连接，提升性能。
异步IO（AIO） 完全异步，效率最高，但编程复杂。

编辑

#IO

上次更新: 2025/06/23, 04:25:07

← HashMap循环数据的删除 Synchronized→