我们简单模拟以下场景：客户端每隔2秒向服务端发送“hello，world"，然后服务端接收并打印。
IO编程
下面是传统IO编程服务端代码：
IOServer.java
public class IOServer {
public static void main(String[] args) throws Exception {
ServerSocket serverSocket = new soc(8000);
System.out.println("server is starting...");
// 接收新连接线程
new Thread(() -> {
while (true) {
try {
// (1) 阻塞方法获取新的连接
Socket socket = serverSocket.accept();
System.out.println(socket.getInetAddress()+":"+socket.getPort()+"加入连接");
// (2) 每一个新的连接都创建一个线程，负责读取数据
new Thread(() -> {
try {
byte[] data = new byte[1024];
InputStream inputStream = socket.getInputStream();
while (true) {
int len;
// (3) 按字节流方式读取数据
while ((len = inputStream.read(data)) != -1) {
System.out.println(new String(data, 0, len));
}
}
} catch (IOException e) {
}
}).start();
} catch (IOException e) {
}
}
}).start();
}
}
server端首先初始化一个8000监听端口的serverSocket，然后开启一个线程不断地去调用堵塞方法accept去获取新的连接，当获取到新的连接后，就给每条连接创建一条线程，该线程就去负责以流的方式读取该连接所带过来的数据。
下面是传统IO编程客户端代码：
IOClient.java
public class IOClient {
public static void main(String[] args) {
new Thread(() -> {
try {
Socket socket = new Socket("127.0.0.1", 8000);
while (true) {
try {
socket.getOutputStream().write((new Date() + ": hello world").getBytes());
socket.getOutputStream().flush();
Thread.sleep(2000);
} catch (Exception e) {
}
}
} catch (IOException e) {
}
}).start();
}
}
客户端的代码比较简单，连上服务端的8000端口，然后每隔2秒发送一条信息。
理解模型
咱们简单举个例子，你就能很快理解IO工作流程。有一个餐厅，大门那有一个接待员，每来一个客人，接待员就叫一个服务员到客人桌前去等待客人点菜。来一个客户人就需要一个服务员过去接待，十个客人就需要十个服务员过去接待，那么问题来了，这个餐厅能赚到钱吗？
JDK1.4提供了NIO（New IO）API
NIO编程
下面是NIO编程服务端代码：
NIOServer.java
public class NIOServer {
// 通道管理器
private Selector selector;
/**
* 获得一个ServerSocket通道，并对该通道做一些初始化的工作
*
* @param port
* 绑定的端口号
* @throws IOException
*/
public void initServer(int port) throws IOException {
// 获得一个ServerSocket通道
ServerSocketChannel serverChannel = ServerSocketChannel.open();
// 设置通道为非阻塞
serverChannel.configureBlocking(false);
// 将该通道对应的ServerSocket绑定到port端口
serverChannel.socket().bind(new InetSocketAddress(port));
// 获得一个通道管理器
this.selector = Selector.open();
// 将通道管理器和该通道绑定，并为该通道注册SelectionKey.OP_ACCEPT事件,注册该事件后，
// 当该事件到达时，selector.select()会返回，如果该事件没到达selector.select()会一直阻塞。
serverChannel.register(selector, SelectionKey.OP_ACCEPT);
}
/**
* 采用轮询的方式监听selector上是否有需要处理的事件，如果有，则进行处理
*
* @throws IOException
*/
public void listen() throws IOException {
System.out.println("服务端启动成功！");
// 轮询访问selector
while (true) {
// 当注册的事件到达时，方法返回，接着往下执行；否则,该方法会一直阻塞
selector.select();
// 获得selector中选中的项的迭代器，选中的项为注册的事件
Iterator<?> ite = this.selector.selectedKeys().iterator();
while (ite.hasNext()) {
SelectionKey key = (SelectionKey) ite.next();
// 删除已选的key,以防重复处理
ite.remove();
handler(key);
}
}
}
/**
* 处理请求
*
* @param key
* @throws IOException
*/
public void handler(SelectionKey key) throws IOException {
// 客户端请求连接事件
if (key.isAcceptable()) {
handlerAccept(key);
// 获得了可读的事件
} else if (key.isReadable()) {
handelerRead(key);
}
}
/**
* 处理连接请求
*
* @param key
* @throws IOException
*/
public void handlerAccept(SelectionKey key) throws IOException {
ServerSocketChannel server = (ServerSocketChannel) key.channel();
// 获得和客户端连接的通道
SocketChannel channel = server.accept();
// 设置成非阻塞
channel.configureBlocking(false);
// 在这里可以给客户端发送信息哦
System.out.println("新的客户端连接");
// 在和客户端连接成功之后，为了可以接收到客户端的信息，需要给通道设置读的权限。
channel.register(this.selector, SelectionKey.OP_READ);
}
/**
* 处理读的事件
*
* @param key
* @throws IOException
*/
public void handelerRead(SelectionKey key) throws IOException {
// 服务器可读取消息:得到事件发生的Socket通道
SocketChannel channel = (SocketChannel) key.channel();
// 创建读取的缓冲区
ByteBuffer buffer = ByteBuffer.allocate(1024);
int read = channel.read(buffer);
if(read > 0){
byte[] data = buffer.array();
String msg = new String(data).trim();
System.out.println("服务端收到信息：" + msg);
//回写数据
ByteBuffer outBuffer = ByteBuffer.wrap("好的".getBytes());
channel.write(outBuffer);// 将消息回送给客户端
}else{
System.out.println("客户端关闭");
key.cancel();
}
}
/**
* 启动服务端测试
*
* @throws IOException
*/
public static void main(String[] args) throws IOException {
NIOServer server = new NIOServer();
server.initServer(8000);
server.listen();
}
}
这段代码比较复杂，所以我都加了注释。我们还是先对照NIO来解释一下几个核心思路。
先简单说一下NIO核心三要素：
- Channel：通道，可以理解为水管，用来传递消息的
- Buffer：缓冲区，用于和NIO通道进行交互。如你所知，数据是从通道读入缓冲区，从缓冲区写入到通道中的
- Selector：选择器，能够检测一到多个NIO通道(channel)，并能够知晓通道是否为诸如读写事件做好准备的组件。这样，一个单独的线程可以管理多个channel，从而管理多个网络连接。
关于这三部分相关的API，后面会继续分析，现在暂时了解。
理解了这三个要素，那上面的代码看起来就没那复杂了。
1.首先，初始化一个通道ServerSocketChannel，给该通道注册SelectionKey.OP_ACCEPT事件，然后与轮询器selector绑定；
2.接着，当新连接过来后就判断SelectionKey的事件类型，如果是isAcceptable可连接事件，则表示是新的通道，需要给该通道绑定SelectionKey.OP_READ事件，以便传递消息；如果是isReadable可读事件，则去缓冲区buffer去读取客户端发过来的消息，当然，也可以给客户端回写消息。
理解模型
同样是餐厅，当客人来了之后，接待员安排一个服务员，服务员给客人一张菜单后，然后回到大门处等待，当客人选完菜之后在喊服务员过去。这样，一个服务员可以同时服务几位甚至十几位客户，大大节约了餐厅成本。
总结
| IO | NIO |
|---|---|
| 面向流 | 面向缓冲 |
| 阻塞IO | 非阻塞IO |
| 无 | 选择器 |
NIO可让您只使用一个（或几个）单线程管理多个通道（网络连接或文件），但付出的代价是解析数据可能会比从一个阻塞流中读取数据更复杂。
如果需要管理同时打开的成千上万个连接，这些连接每次只是发送少量的数据，例如聊天服务器，实现NIO的服务器可能是一个优势。同样，如果你需要维持许多打开的连接到其他计算机上，如P2P网络中，使用一个单独的线程来管理你所有出站连接，可能是一个优势。
Java NIO: 单线程管理多个连接
如果你有少量的连接使用非常高的带宽，一次发送大量的数据，也许典型的IO服务器实现可能非常契合。
Java IO: 一个典型的IO服务器设计- 一个连接通过一个线程处理