前面的文章，我们讲述了BIO的概念，以及编程模型，由于BIO中服务器端的一些阻塞的点，导致服务端对于每一个客户端连接，都要开辟一个线程来处理，导致资源浪费，效率低。
为此，Linux 内核系统调用开始支持NIO（non-blocking IO），非阻塞IO，将之前BIO中的一些阻塞点，改为非阻塞，体现在Java API中就是：
服务端：
服务器等待客户端连接的accept方法不阻塞；java api中accept
服务器读取客户端数据不阻塞阻塞；java api中read
Java NIO编程中，主要涉及以下三个主要概念：
1.Channel ：IO操作的联结，代表硬件，文件，网络套接字的连接，对应于BIO中的Socket； Channel需要与Buffer结合使用
2.Buffer：用于数据操作的缓冲区，就是一块内存，提供了一些操作，方便使用；
3.Selector：选择器，就是Linux 内核中的IO多路复用器，为了提高网络IO编程的效率，常用的有select， poll， epoll， 可以参考Linux对应系统调用
这三个概念，我们在后面的编程模型都会涉及。
下面我们先基于Channel和Buffer实现一个简单的服务端，用之前的BIO实现一个客户端；
Channel和Buffer对应的API的返回值含义，我都会在代码中注释清楚：
需求：
服务端：基于NIO，可以非阻塞的接收客户端连接，对客户端采用轮询接收数据
客户端：基于BIO，连接服务端，并发送数据
服务端代码：
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
/**
* 基于NIO中的Channel和Buffer实现服务端，对客户端采用轮询
*
* @author freddy
*/
class NIOServer {
public static void main(String[] args) throws IOException {
ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
serverSocketChannel.configureBlocking(false); // 非阻塞
serverSocketChannel.bind(new InetSocketAddress(9090));
List<SocketChannel> clients = new LinkedList<>();
while (true) {
try {
Thread.sleep(3000); // 为了方便测试观察
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
// accept非阻塞, 没有连接时，返回null
SocketChannel client = serverSocketChannel.accept();
if (client != null) {
// 设置client非阻塞
client.configureBlocking(false);
clients.add(client);
}
// 遍历处理所有的client，看有没有数据可以读取
Iterator<SocketChannel> iterator = clients.iterator();
ByteBuffer buffer = ByteBuffer.allocate(1024); // 共用buffer
System.out.println("clients size :" + clients.size());
while (iterator.hasNext()) {
SocketChannel clientSocket = iterator.next();
try {
int len = clientSocket.read(buffer); // read()返回：>0:读取到数据 0:没读到数据 -1:连接关闭
if (len > 0) {
// 读取到数据后，进行打印
buffer.flip();
byte[] bytes = new byte[buffer.limit()];
System.out.println(clientSocket + "read data len:" + bytes.length);
buffer.get(bytes);
System.out.println(clientSocket + " data: " + new String(bytes));
} else if (len == 0) {
System.out.println(clientSocket + " no data");
} else if (len == -1) {
// 连接关闭
iterator.remove();
System.out.println(clientSocket + " close, remove");
}
buffer.clear();
} catch (IOException exception) {
iterator.remove();
System.out.println(clientSocket + " disconnect, remove");
}
}
}
}
}
客户端代码：
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
/**
* 基于BIO的TCP网络通信的客户端，接收控制台输入的数据，然后通过字节流发送给服务端
*
* @author freddy
*/
class ChatClient {
public static void main(String[] args) throws IOException {
// 连接server
Socket serverSocket = new Socket("localhost", 9090);
System.out.println("client connected to server");
// 读取用户在控制台上的输入，并发送给服务器
new Thread(new ClientThread(serverSocket)).start();
// 接收服务端发送过来的数据
try (InputStream serverSocketInputStream = serverSocket.getInputStream();) {
byte[] buffer = new byte[1024];
int len;
while ((len = serverSocketInputStream.read(buffer)) != -1) {
String data = new String(buffer, 0, len);
System.out.println(
"client receive data from server" + serverSocketInputStream + " data size：" + len + ": " + data);
}
}
}
}
class ClientThread implements Runnable {
private Socket serverSocket;
public ClientThread(Socket serverSocket) {
this.serverSocket = serverSocket;
}
@Override
public void run() {
// 读取用户在控制台上的输入，并发送给服务器
InputStream in = System.in;
byte[] buffer = new byte[1024];
int len;
try (OutputStream outputStream = serverSocket.getOutputStream();) {
// read操作阻塞，直到有数据可读，由于后面还要接收服务端转发过来的数据，这两个操作都是阻塞的，所以需要两个线程
while ((len = in.read(buffer)) != -1) {
String data = new String(buffer, 0, len);
System.out.println("client receive data from console" + in + " : " + new String(buffer, 0, len));
if ("exit\n".equals(data)) {
// 模拟客户端关闭连接
System.out.println("client close :" + serverSocket);
// 这里跳出循环后，try-with-resources 会自动关闭outputStream
break;
}
// 发送数据给服务器端
outputStream.write(new String(buffer, 0, len).getBytes()); // 此时buffer中是有换行符
}
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
测试：
先开启服务端，再开启两个客户端发送数据，服务端接受连接后，会打印当前接受到的客户端总数，然后轮询接收数据后打印；
当客户端发送exit后，客户端会关闭连接，服务端会识别到，去除该客户端；
当客户端发进程异常关闭后，客户端会断开连接，服务端会识别到，去除该客户端；
测试日志：
客户端1和2，正常发送数据
图1
客户端1发送exit后，关闭连接
客户端2断开连接
可以直接在Idea中关闭客户端2的程序，或者用nc命令模拟，Ctrl+C关闭nc
clients size :1
java.nio.channels.SocketChannel[connected local=/127.0.0.1:9090 remote=/127.0.0.1:17914] no data
clients size :1
java.nio.channels.SocketChannel[connected local=/127.0.0.1:9090 remote=/127.0.0.1:17914] disconnect, remove
clients size :0
clients size :0我们在上面的图1中，可以看到，客户端短期内发送的两次内容，是在服务端一次性读到的；这个就是粘包、拆包现象的一种，后面我们会看。
