更多 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 <i>position</i> 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 <i>limit</i> 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 <i>capacity</i> 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
- SelectionKey.OP_CONNECT：TCP 连接
- 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：得到附加对象
-
- 如果一个 Channel 要注册到 Selector 中, 那么这个 Channel 必须是非阻塞的, 即
-
不断重复：
- 调用 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<SelectionKey> 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
}
}
}
}
