1
public abstract class Buffer {
2
    // Invariants: mark <= position <= limit <= capacity
3
    private int mark = -1;
4
    private int position = 0;
5
    private int limit;
6
    private int capacity;
7
}

1
// 分配堆内存
2
public static ByteBuffer allocate(int capacity);
3
// 分配直接内存
4
public static ByteBuffer allocateDirect(int capacity);

1
import java.nio.*;
2

3
public class CharBufferDemo {
4
    public static void main(String[] args) {
5
        // 分配一个容量为8的CharBuffer
6
        CharBuffer buffer = CharBuffer.allocate(8);
7
        System.out.println("初始状态：");
8
        printState(buffer);
9

10
        // 向buffer写入3个字符
11
        buffer.put('a').put('b').put('c');
12
        System.out.println("写入3个字符后的状态：");
13
        printState(buffer);
14

15
        // 调用flip()方法，准备读取buffer中的数据，将 position 置 0,limit 的置 3
16
        buffer.flip();
17
        System.out.println("调用flip()方法后的状态：");
18
        printState(buffer);
19

20
        // 读取字符
21
        while (buffer.hasRemaining()) {
22
            System.out.print(buffer.get());
23
        }
24

25
        // 调用clear()方法，清空缓冲区，将 position 的值置为 0，将 limit 的值置为 capacity 的值
26
        buffer.clear();
27
        System.out.println("调用clear()方法后的状态：");
28
        printState(buffer);
29

30
    }
31

32
    // 打印buffer的capacity、limit、position、mark的位置
33
    private static void printState(CharBuffer buffer) {
34
        System.out.print("capacity: " + buffer.capacity());
35
        System.out.print(", limit: " + buffer.limit());
36
        System.out.print(", position: " + buffer.position());
37
        System.out.print(", mark 开始读取的字符: " + buffer.mark());
38
        System.out.println("\\n");
39
    }
40
}

1
初始状态：
2
capacity: 8, limit: 8, position: 0
3

4
写入3个字符后的状态：
5
capacity: 8, limit: 8, position: 3
6

7
准备读取buffer中的数据！
8

9
调用flip()方法后的状态：
10
capacity: 8, limit: 3, position: 0
11

12
读取到的数据：abc
13

14
调用clear()方法后的状态：
15
capacity: 8, limit: 8, position: 0

1
RandomAccessFile reader = new RandomAccessFile("test_read.in", "r"))
2
FileChannel channel = reader.getChannel();
3
ByteBuffer buffer = ByteBuffer.allocate(1024);
4
channel.read(buffer);

1
Set<SelectionKey> selectedKeys = selector.selectedKeys();
2
Iterator<SelectionKey> keyIterator = selectedKeys.iterator();
3
while (keyIterator.hasNext()) {
4
    SelectionKey key = keyIterator.next();
5
    if (key != null) {
6
        if (key.isAcceptable()) {
7
            // ServerSocketChannel が新しい接続を受け付けた
8
        } else if (key.isConnectable()) {
9
            // 新しい接続が確立したことを示す
10
        } else if (key.isReadable()) {
11
            // Channel に準備されたデータがあり、読み取れる
12
        } else if (key.isWritable()) {
13
            // Channel に空きのあるバッファがあり、データを書き込める
14
        }
15
    }
16
    keyIterator.remove();
17
}

1
import java.io.IOException;
2
import java.net.InetSocketAddress;
3
import java.nio.ByteBuffer;
4
import java.nio.channels.SelectionKey;
5
import java.nio.channels.Selector;
6
import java.nio.channels.ServerSocketChannel;
7
import java.nio.channels.SocketChannel;
8
import java.util.Iterator;
9
import java.util.Set;
10

11
public class NioSelectorExample {
12

13
  public static void main(String[] args) {
14
    try {
15
      ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
16
      serverSocketChannel.configureBlocking(false);
17
      serverSocketChannel.socket().bind(new InetSocketAddress(8080));
18

19
      Selector selector = Selector.open();
20
      // 将 ServerSocketChannel 注册到 Selector 并监听 OP_ACCEPT 事件
21
      serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
22

23
      while (true) {
24
        int readyChannels = selector.select();
25

26
        if (readyChannels == 0) {
27
          continue;
28
        }
29

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

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

36
          if (key.isAcceptable()) {
37
            // 处理连接事件
38
            ServerSocketChannel server = (ServerSocketChannel) key.channel();
39
            SocketChannel client = server.accept();
40
            client.configureBlocking(false);
41

42
            // 将客户端通道注册到 Selector 并监听 OP_READ 事件
43
            client.register(selector, SelectionKey.OP_READ);
44
          } else if (key.isReadable()) {
45
            // 处理读事件
46
            SocketChannel client = (SocketChannel) key.channel();
47
            ByteBuffer buffer = ByteBuffer.allocate(1024);
48
            int bytesRead = client.read(buffer);
49

50
            if (bytesRead > 0) {
51
              buffer.flip();
52
              System.out.println("收到数据：" +new String(buffer.array(), 0, bytesRead));
53
              // 将客户端通道注册到 Selector 并监听 OP_WRITE 事件
54
              client.register(selector, SelectionKey.OP_WRITE);
55
            } else if (bytesRead < 0) {
56
              // 客户端断开连接
57
              client.close();
58
            }
59
          } else if (key.isWritable()) {
60
            // 处理写事件
61
            SocketChannel client = (SocketChannel) key.channel();
62
            ByteBuffer buffer = ByteBuffer.wrap("Hello, Client!".getBytes());
63
            client.write(buffer);
64

65
            // 将客户端通道注册到 Selector 并监听 OP_READ 事件
66
            client.register(selector, SelectionKey.OP_READ);
67
          }
68

69
          keyIterator.remove();
70
        }
71
      }
72
    } catch (IOException e) {
73
      e.printStackTrace();
74
    }
75
  }
76
}