前面在Tomcat中讲解了两个通道，BIO和NIO，我们这里来通过两端程序，简单模拟两个通道，找找异同点：
BIO：
1.
public class SocketServer {
public SocketServer() {
try {
int clientcount = 0; // 统计客户端总数
boolean listening = true; // 是否对客户端进行监听
ServerSocket server = null; // 服务器端Socket对象
try {
// 创建一个ServerSocket在端口2121监听客户请求
server = new ServerSocket(2121);
System.out.println("Server starts...");
} catch (Exception e) {
System.out.println("Can not listen to. " + e);
}
while (listening) {
// 客户端计数
clientcount++;
// 监听到客户请求,根据得到的Socket对象和客户计数创建服务线程,并启动之
new ServerThread(server.accept(), clientcount).start(); ====》一请求，一线程，这个就是模拟Tomcat的前端的
}
} catch (Exception e) {
System.out.println("Error. " + e);
}
}
public static void main(String[] args) {
new SocketServer();
}
}
上面的这一段代码，在Tomcat中实质就是Acceptor线程。
2.
对应Tomcat的工作线程实际上就是ServerThread这个类：
public class ServerThread extends Thread {
private static int number = 0; // 保存本进程的客户计数
Socket socket = null; // 保存与本线程相关的Socket对象
public ServerThread(Socket socket, int clientnum) {
this.socket = socket;
}
public void run() {
try {
BufferedReader in = new BufferedReader(new InputStreamReader(socket
.getInputStream()));
PrintWriter out = new PrintWriter(socket.getOutputStream()); //从socket中获取流
BufferedReader sysin = new BufferedReader(new InputStreamReader(
System.in));
System.out.println("[Client " + number + "]: " + in.readLine());
String line;
line = sysin.readLine(); //流式读取
while (!line.equals("bye")) { // 如果该字符串为 "bye",则停止循环
out.println(line);
out.flush(); 流式写入与刷新
System.out.println("[Server]: " + line);
System.out.println("[Client " + number + "]: " + in.readLine());
line = sysin.readLine();
}
out.close(); // 关闭Socket输出流
in.close(); // 关闭Socket输入流
socket.close(); // 关闭Socket
} catch (Exception e) {
System.out.println("Error. " + e);
}
}
}
上述的工作线程，直接在这里进行了处理，在Tomcat中，这个流程非常复杂，后续的代码一直延伸到Tomcat的后端容器当中。
总结一下，其实BIO的模式很明白，一线程一个请求，从上面的例子中已经看得很清晰，
而socket的读取是流式的读取，也就是从socket中获得流，直接通过java,io进行流的读取。
NIO：
public class NIOServer {
/*标识数字*/
private int flag = 0;
/*缓冲区大小*/
private int BLOCK = 4096;
/*接受数据缓冲区*/
private ByteBuffer sendbuffer = ByteBuffer.allocate(BLOCK);
/*发送数据缓冲区*/
private ByteBuffer receivebuffer = ByteBuffer.allocate(BLOCK);
private Selector selector;
public NIOServer(int port) throws IOException {
//======>这个相当于Tomcat中Acceptor线程，只不过这里对通道进行了再次包装，对SelectionKey进行传入，
// 打开服务器套接字通道
ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
// 服务器配置为非阻塞
serverSocketChannel.configureBlocking(false);
// 检索与此通道关联的服务器套接字
ServerSocket serverSocket = serverSocketChannel.socket();
// 进行服务的绑定
serverSocket.bind(new InetSocketAddress(port));
// 通过open()方法找到Selector
selector = Selector.open();
// 注册到selector，等待连接
serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
System.out.println("Server Start----8888:");
}
private void listen() throws IOException {
//======> 这个相当于Tomcat中Poller线程，对前面包装的SelectionKey进行轮询，并通过handleKey传递到工作线程中去
while (true) {
// 选择一组键，并且相应的通道已经打开
selector.select();
// 返回此选择器的已选择键集。
Set<SelectionKey> selectionKeys = selector.selectedKeys();
Iterator<SelectionKey> iterator = selectionKeys.iterator();
while (iterator.hasNext()) {
SelectionKey selectionKey = iterator.next();
iterator.remove();
handleKey(selectionKey);
}
}
}
// 处理请求
//======>这下面直接就是工作线程，进入Tomcat容器的环节中，并最终返回调用的结果
private void handleKey(SelectionKey selectionKey) throws IOException {
// 接受请求
ServerSocketChannel server = null;
SocketChannel client = null;
String receiveText;
String sendText;
int count=0;
// 测试此键的通道是否已准备好接受新的套接字连接。
if (selectionKey.isAcceptable()) {
// 返回为之创建此键的通道。
server = (ServerSocketChannel) selectionKey.channel();
// 接受到此通道套接字的连接。
// 此方法返回的套接字通道（如果有）将处于阻塞模式。
client = server.accept();
// 配置为非阻塞
client.configureBlocking(false);
// 注册到selector，等待连接
client.register(selector, SelectionKey.OP_READ);
} else if (selectionKey.isReadable()) {
// 返回为之创建此键的通道。
client = (SocketChannel) selectionKey.channel();
//将缓冲区清空以备下次读取
receivebuffer.clear();
//读取服务器发送来的数据到缓冲区中
count = client.read(receivebuffer);
if (count > 0) {
receiveText = new String( receivebuffer.array(),0,count);
System.out.println("服务器端接受客户端数据--:"+receiveText);
client.register(selector, SelectionKey.OP_WRITE);
}
} else if (selectionKey.isWritable()) {
//将缓冲区清空以备下次写入
sendbuffer.clear();
// 返回为之创建此键的通道。
client = (SocketChannel) selectionKey.channel();
sendText="message from server--" + flag++;
//向缓冲区中输入数据
sendbuffer.put(sendText.getBytes());
//将缓冲区各标志复位,因为向里面put了数据标志被改变要想从中读取数据发向服务器,就要复位
sendbuffer.flip();
//输出到通道
client.write(sendbuffer);
System.out.println("服务器端向客户端发送数据--："+sendText);
client.register(selector, SelectionKey.OP_READ);
}
}
/**
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
int port = 8888;
NIOServer server = new NIOServer(port);
server.listen();
}
}
总结一下，上述的NIO程序中的几个阶段，可以反映出Tomcat的NIO的前端线程池的工作模式，只不过上面的代码是串行的，而Tomcat中是通过几个线程池进行交接的，每个线程池之间需要共享一些数据用于传递。
最后，在笔者编写NIO的程序出了几个几个错误，提醒一下各位，我们需要注意一下：
1.上述在每一次selectkey轮询出来的时候，需要注意最后一句话，例如当Accept事件发生后，SocketChannel需要改变自身关注的事件，因为这个时候如果还关注Accept事件，那相当于什么都发生不了，因为这个时候SocketChannel已经再发送数据了，相当于只有监测Read和Write事件才能拿到Socket的输入和输出。因此，可以看到当Accept事件发生后：
client.register(selector, SelectionKey.OP_READ);
重新注册Read事件。
再来看看Read事件的最后一句话，注册的是Write事件
client.register(selector, SelectionKey.OP_WRITE);
这个是因为读取完成后，立刻就要发送一些内容，所以需要改变SocketChannel的工作模式，将其置为WRITE模式。
同理，对于READ事件之后，同样立刻要读取客户端的数据，这个还得重新注册Read事件；
对于上述的通道模式的改变，Tomcat是将这些封装到NioChannel中，不断基于socket的工作模式进行切换。
2.还有一个值得注意的事情，就是buffer缓冲区的flip操作，首先需要注意的是三个buffer的属性：
这三个属性，根据读模式和写模式的不同而不同
capacity：
- 容量，无论是写模式，还是读模式，容量都是固定的
- position：指当前的位置
- 写模式时，position表示当前的位置。初始的position值为0.当一个byte、long等数据写到Buffer后， position会向前移动到下一个可插入数据的Buffer单元。position最大可为capacity – 1.
-
读模式时，也是从某个特定位置读。当将Buffer从写模式切换到读模式，position会被重置为0. 当从Buffer的position处读取数据时，position向前移动到下一个可读的位置。
limit：最大能读/写的限制
在写模式下，Buffer的limit表示你最多能往Buffer里写多少数据。 写模式下，limit等于Buffer的capacity。
当切换Buffer到读模式时， limit表示你最多能读到多少数据。因此，当切换Buffer到读模式时，limit会被设置成写模式下的position值。换句话说，你能读到之前写入的所有数据（limit被设置成已写数据的数量，这个值在写模式下就是position）
我们明白上述的原理后，就不难理解，为啥上述的buffer经常要flip一下，flip方法将Buffer从写模式切换到读模式。调用flip()方法会将position设回0，并将limit设置成之前position的值，这样就相当于做好了读的准备，而上述代码中的sendbuffer立马要进行：
/输出到通道
client.write(sendbuffer);
这个client.write方法中，实际是先从buffer中进行读取字节，然后再发送到socket缓冲区中，因此虽然这个表面上看来没有读的意思，但实际上隐藏着读，因此flip操作也是必不可少的。