Java NIO Buffer, Channel 及 Selector

更多 Java IO & NIO方面的文章,请参见文集《Java IO & NIO》


Java IO VS NIO

  • JDK 1.4 之前,java.io 包,面向流的I/O系统(字节流或者字符流)
    • 系统一次处理一个字节
    • 速度慢
  • JDK 1.4 提供,java.nio 包,面向块的I/O系统
    • 系统一次处理一个块
    • 速度快

Buffer 缓冲区

缓冲区实际上是一个容器对象,更直接的说,其实就是一个数组。
在 NIO 库中,所有数据都是用缓冲区处理的:

  • 在读取数据时,它是直接读到缓冲区中的;
  • 在写入数据时,它也是写入到缓冲区中的;

在 NIO 中,所有的缓冲区类型都继承于抽象类 Buffer。常见的缓冲区 Buffer 包括:

  • ByteBuffer 存储了字节数组 final byte[] hb;
  • CharBuffer final char[] hb;
    • ByteBuffer 与 CharBuffer 之间的转换需要使用字符集 Charset
    • Charset 具体使用,参见 Java Charset 字符集
  • ShortBuffer final short[] hb;
  • IntBuffer final int[] hb;
  • LongBuffer final long[] hb;
  • FloatBuffer final float[] hb;
  • DoubleBuffer final double[] hb;

Buffer 类的属性:

  • private int mark = -1; 记录一个标记位置
  • private int position = 0;

A buffer's position is the index of the next element to be read or written. A buffer's position is never negative and is never greater than its limit.
当前操作的位置

  • private int limit;

A buffer's limit is the index of the first element that should not be read or written. A buffer's limit is never negative and is never greater than its capacity.
可以存放的元素的个数

  • private int capacity;

A buffer's capacity is the number of elements it contains. The capacity of a buffer is never negative and never changes.
数组容量

  • 大小关系:mark <= position <= limit <= capacity

Buffer 类的方法:

  • allocate(int capacity) 分配一个缓冲区,默认 limit = capacity
  • put() 在当前位置添加元素
  • get() 得到当前位置的元素
  • clear() 将 Buffer 从 读模式 切换到 写模式 (该方法实际不会清空原 Buffer 的内容)
public final Buffer clear() {
    position = 0;
    limit = capacity;
    mark = -1;
    return this;
}
  • flip() 将 Buffer 从 写模式 切换到 读模式
public final Buffer flip() {
    limit = position;
    position = 0;
    mark = -1;
    return this;
}

** clear() VS flip()**:

  • 在写模式下,Buffer 的 limit 表示你最多能往 Buffer 里写多少数据。
    • 因此写之前,调用 clear(),使得 limit = capacity;
  • 在读模式时,Buffer 的 limit 表示你最多能从 Buffer 里读多少数据。
    • 因此读之前,调用 flip(),使得 limit = position;

IntBuffer 的使用:

public static void main(String[] args) throws Exception {
    // 创建 int 缓冲区 capacity 为 4
    // 默认 limit = capacity
    IntBuffer buffer = IntBuffer.allocate(4);
    System.out.println("Capacity & Limit: " + buffer.capacity() + " " + buffer.limit());

    // 往 Buffer 中写数据
    buffer.put(11);
    buffer.put(22);
    buffer.put(33);
    buffer.put(44);

    System.out.println("Position: " + buffer.position());

    // 在从 Buffer 中读数据之前,调用 flip()
    buffer.flip();

    while (buffer.hasRemaining()) {
        System.out.print(buffer.get() + "  ");
    }
}

输出:

Capacity & Limit: 4 4
Position: 4
11 22 33 44

Channel 通道

  • Java NIO 的核心概念,表示的是对支持 I/O 操作的实体的一个连接
  • 通过它可以读取和写入数据(并不是直接操作,而是通过 Buffer 来处理)
  • 双向的

常用的 Channel 包括:

  • FileChannel 从文件中读写数据
  • DatagramChannel 从 UDP 中读写数据
  • SocketChannel 从 TCP 中读写数据
  • ServerSocketChannel 监听新进来的 TCP 连接,每一个新进来的连接都会创建一个 SocketChannel。

FileChannel 连接到文件的通道

FileChannel 无法设置为非阻塞模式,只能运行在阻塞模式下
常用方法:

  • int read(ByteBuffer dst) 从 Channel 中读取数据,写入 Buffer
  • int write(ByteBuffer src) 从 Buffer 中读取数据,写入 Channel
  • long size() 得到 Channel 中文件的大小
  • long position() 得到 Channel 中文件的当前操作位置
  • FileChannel position(long newPosition) 设置 Channel 中文件的当前操作位置

使用 FileChannel 来复制文件的例子:

public static void main(String[] args) throws Exception {
    // 通过 InputStream 或者 OutputStream 来构造 FileChannel
    FileChannel in = new FileInputStream("a.txt").getChannel();
    FileChannel out = new FileOutputStream("b.txt").getChannel();

    ByteBuffer buffer = ByteBuffer.allocate(1024);

    // 调用 channel 的 read 方法往 Buffer 中写数据
    while(in.read(buffer) != -1) {
        // 在从 Buffer 中读数据之前,调用 flip()
        buffer.flip();
        // 从 Buffer 中读数据,写入到 channel
        out.write(buffer);
        // 在往 Buffer 中写数据之前,调用 clear()
        buffer.clear();
    }

    // 或者使用如下代码
    // out.transferFrom(in, 0, in.size());
}

SocketChannel 连接到 TCP 套接字的通道

SocketChannel 可以设置为阻塞模式或非阻塞模式
使用 SocketChannel 来建立 TCP 连接,发送并接收数据,默认使用 阻塞模式

public static void main(String[] args) throws Exception {
    // 打开 SocketChannel
    SocketChannel channel = SocketChannel.open();
    // connect 方法会阻塞,直至连接建立成功
    channel.connect(new InetSocketAddress("127.0.0.1", 8080));

    ByteBuffer buffer = ByteBuffer.allocate(1024);

    // 发送数据
    String msg = "This is client.";
    // 在往 Buffer 中写数据之前,调用 clear()
    buffer.clear();
    buffer.put(msg.getBytes());

    // 在从 Buffer 中读数据之前,调用 flip()
    buffer.flip();
    channel.write(buffer);

    // 接收数据
    // 在往 Buffer 中写数据之前,调用 clear()
    buffer.clear();

    // 调用 channel 的 read 方法往 Buffer 中写数据
    channel.read(buffer);

    // 在从 Buffer 中读数据之前,调用 flip()
    buffer.flip();

    // 从 Buffer 中读数据
    while (buffer.hasRemaining()) {
        System.out.print(buffer.get());
    }
}

使用 SocketChannel 的 非阻塞模式 来建立 TCP 连接,发送并接收数据:

public static void main(String[] args) throws Exception {
    // 打开 SocketChannel
    SocketChannel channel = SocketChannel.open();

    channel.configureBlocking(false);
    channel.connect(new InetSocketAddress("127.0.0.1", 8080));

    ByteBuffer buffer = ByteBuffer.allocate(1024);

    while (!channel.finishConnect()) {
        // 发送数据
        String msg = "This is client.";
        // 在往 Buffer 中写数据之前,调用 clear()
        buffer.clear();
        buffer.put(msg.getBytes());

        // 在从 Buffer 中读数据之前,调用 flip()
        buffer.flip();
        channel.write(buffer);

        // 接收数据
        // 在往 Buffer 中写数据之前,调用 clear()
        buffer.clear();

        // 调用 channel 的 read 方法往 Buffer 中写数据
        channel.read(buffer);

        // 在从 Buffer 中读数据之前,调用 flip()
        buffer.flip();

        // 从 Buffer 中读数据
        while (buffer.hasRemaining()) {
            System.out.print(buffer.get());
        }
    }
}

ServerSocketChannel 监听 TCP 连接的通道

ServerSocketChannel 可以设置为阻塞模式或非阻塞模式
使用 ServerSocketChannel 来监听 TCP 连接,默认使用 阻塞模式

public static void main(String[] args) throws Exception {
    // 打开 SocketChannel
    ServerSocketChannel channel = ServerSocketChannel.open();
    // 绑定端口
    channel.socket().bind(new InetSocketAddress(8080));

    ByteBuffer buffer = ByteBuffer.allocate(1024);

    while (true) {
        // accept 方法会阻塞,直至监听到 TCP 连接
        SocketChannel socketChannel = channel.accept();
        System.out.println("A new connection...");

        // 接收数据
        // 在往 Buffer 中写数据之前,调用 clear()
        buffer.clear();

        // 调用 channel 的 read 方法往 Buffer 中写数据
        socketChannel.read(buffer);

        // 在从 Buffer 中读数据之前,调用 flip()
        buffer.flip();

        // 从 Buffer 中读数据
        while (buffer.hasRemaining()) {
            System.out.print(buffer.get());
        }

        // 在往 Buffer 中写数据之前,调用 clear()
        // 发送数据
        String msg = "This is server.";
        // 在往 Buffer 中写数据之前,调用 clear()
        buffer.clear();
        buffer.put(msg.getBytes());

        // 在从 Buffer 中读数据之前,调用 flip()
        buffer.flip();
        socketChannel.write(buffer);
    }
}

Selector 选择器

Selector 允许单个进程可以同时处理多个网络连接的 IO,即监听多个端口的 Channel

关于 IO 模式,参见 Linux IO 模型 中对多路复用 IO Multiplexing IO 的说明。

引用:


多路复用 IO Multiplexing IO

  • 单个进程可以同时处理多个网络连接的 IO,即监听多个端口的 IO
  • 适用于连接数很高的情况
  • 实现方式:select,poll,epoll 系统调用
    • 注册多个端口的监听 Socket,比如 8080,8081
    • 当用户进程调用 select 方法后,整个用户进程被阻塞,OS 内核会监听所有注册的 Socket
    • 当任何一个端口的 Socket 中的数据准备好了( 8080 或者 8081),select 方法就会返回
    • 随后用户进程再调用 read 操作,将数据从 OS 内核缓存区拷贝到应用程序的地址空间。
  • 多路复用 IO 类似于 多线程结合阻塞 IO
    • 要实现监听多个端口的 IO,还可以通过多线程的方式,每一个线程负责监听一个端口的 IO
    • 如果处理的连接数不是很高的话,使用 多路复用 IO 不一定比使用 多线程结合阻塞 IO 的服务器性能更好,可能延迟还更大
    • 多路复用 IO 的优势并不是对于单个连接能处理得更快,而是在于能处理更多的连接

Selector 使用步骤:

  • 创建 Selector
  • 创建 Channel,可以创建多个 Channel,即监听多个端口,比如 8080,8081
  • 将 Channel 注册到 Selector 中
    • 如果一个 Channel 要注册到 Selector 中, 那么这个 Channel 必须是非阻塞的, 即 channel.configureBlocking(false);
    • 因此 FileChannel 是不能够使用 Selector 的, 因为 FileChannel 都是阻塞的
    • 注册时,需要指定了对 Channel 的什么事件感兴趣,包括:
      • SelectionKey.OP_CONNECT:TCP 连接 static final int OP_CONNECT = 1 << 3;
      • SelectionKey.OP_ACCEPT:确认 static final int OP_ACCEPT = 1 << 4;
      • SelectionKey.OP_READ:读 static final int OP_READ = 1 << 0;
      • SelectionKey.OP_WRITE:写 static final int OP_WRITE = 1 << 2;
      • 可以使用或运算 | 来组合,例如 SelectionKey.OP_READ | SelectionKey.OP_WRITE
    • register 方法返回一个 SelectionKey 对象,包括:
      • int interestOps():调用 register 注册 channel 时所设置的 interest set.
      • int readyOps():Channel 所准备好了的操作
        • selectionKey.isAcceptable();
        • selectionKey.isConnectable();
        • selectionKey.isReadable();
        • selectionKey.isWritable();
      • public abstract SelectableChannel channel();: 得到 Channel
      • public abstract Selector selector();:得到 Selector
      • public final Object attachment:得到附加对象
  • 不断重复:
    • 调用 Selector 对象的 select() 方法,该方法会阻塞,直至注册的事件发生
    • 事件发生,调用 Selector 对象的 selectedKeys() 方法获取 selected keys
    • 遍历每个 selected key:
      • 从 selected key 中获取对应的 Channel 并处理
      • 在 OP_ACCEPT 事件中, 从 key.channel() 返回的是 ServerSocketChannel
      • 在 OP_WRITE 和 OP_READ 事件中, 从 key.channel() 返回的是 SocketChannel
  • 关闭 Selector

示例:

public static void main(String args[]) throws Exception {
    // 创建 Selector
    Selector selector = Selector.open();

    // 创建 Server Socket,监听端口 8080
    ServerSocketChannel serverChannel1 = ServerSocketChannel.open();
    serverChannel1.socket().bind(new InetSocketAddress(8080));
    // 如果一个 Channel 要注册到 Selector 中, 那么这个 Channel 必须是非阻塞的
    serverChannel1.configureBlocking(false);

    // 创建 Server Socket,监听端口 8081
    ServerSocketChannel serverChannel2 = ServerSocketChannel.open();
    serverChannel2.socket().bind(new InetSocketAddress(8081));
    // 如果一个 Channel 要注册到 Selector 中, 那么这个 Channel 必须是非阻塞的
    serverChannel2.configureBlocking(false);

    // 将 Channel 注册到 Selector 中
    serverChannel1.register(selector, SelectionKey.OP_ACCEPT);
    serverChannel2.register(selector, SelectionKey.OP_ACCEPT);

    // 不断重复
    while (true) {
        // 调用 Selector 对象的 select() 方法,该方法会阻塞,直至注册的事件发生
        selector.select();

        // 事件发生,调用 Selector 对象的 selectedKeys() 方法获取 selected keys
        Iterator it = selector.selectedKeys().iterator();

        // 遍历每个 selected key:
        while (it.hasNext()) {
            SelectionKey key = it.next();

            if (key.isAcceptable()) {
                // 在 OP_ACCEPT 事件中, 从 key.channel() 返回的是 ServerSocketChannel
                ServerSocketChannel serverChannel = (ServerSocketChannel) key.channel();

                // 调用 accept 方法获取 TCP 连接 SocketChanne
                SocketChannel clientChannel = serverChannel.accept();
                clientChannel.configureBlocking(false);

                // 注册 SocketChannel
                clientChannel.register(key.selector(), SelectionKey.OP_READ | SelectionKey.OP_WRITE);

                System.out.println("Accept event");
            }

            if (key.isReadable()) {
                // 在 OP_WRITE 和 OP_READ 事件中, 从 key.channel() 返回的是 SocketChannel
                SocketChannel clientChannel = (SocketChannel) key.channel();
                System.out.println("Read event");
                // 可以从 clientChannel 中读数据,通过 ByteBuffer
                // TO DO
            }

            if (key.isWritable()) {
                // 在 OP_WRITE 和 OP_READ 事件中, 从 key.channel() 返回的是 SocketChannel
                SocketChannel clientChannel = (SocketChannel) key.channel();
                System.out.println("Write event");
                // 可以向 clientChannel 中写数据,通过 ByteBuffer
                // TO DO
            }
        }
    }
}

你可能感兴趣的:(Java NIO Buffer, Channel 及 Selector)