基于NIO和BIO的两种服务器对比

基于BIO的服务器，服务端可能要同时保持几百万个HTTP连接，而这些连接并不是每时每刻都在传输数据，所以这种情况不适合使用BIO的服务器；而且需要保证共享资源的同步与安全，这个实现起来相对复杂。这时候就是基于NIO的服务器出场的时候了。

先来比较下两种服务器的代码

1.NIO实现

 public class SelectorServer
 {
     private static int PORT = 1234;

     public static void main(String[] args) throws Exception
     {
         // 先确定端口号
         int port = PORT;
         if (args != null && args.length > 0)
         {
             port = Integer.parseInt(args[0]);
         }
         // 打开一个ServerSocketChannel
         ServerSocketChannel ssc = ServerSocketChannel.open();
         // 获取ServerSocketChannel绑定的Socket
         ServerSocket ss = ssc.socket();
         // 设置ServerSocket监听的端口
         ss.bind(new InetSocketAddress(port));
         // 设置ServerSocketChannel为非阻塞模式
         ssc.configureBlocking(false);
         // 打开一个选择器
         Selector selector = Selector.open();
         // 将ServerSocketChannel注册到选择器上去并监听accept事件
         ssc.register(selector, SelectionKey.OP_ACCEPT);
         while (true)
         {
             // 这里会发生阻塞，等待就绪的通道
             int n = selector.select();
             // 没有就绪的通道则什么也不做
             if (n == 0)
             {
                 continue;
             }
             // 获取SelectionKeys上已经就绪的通道的集合
             Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
             // 遍历每一个Key
             while (iterator.hasNext())
             {
                 SelectionKey sk = iterator.next();
                 // 通道上是否有可接受的连接
                 if (sk.isAcceptable())
                 {
                     ServerSocketChannel ssc1 = (ServerSocketChannel)sk.channel();
                     SocketChannel sc = ssc1.accept();
                     sc.configureBlocking(false);
                     sc.register(selector, SelectionKey.OP_READ);
                 }
                 // 通道上是否有数据可读
                 else if (sk.isReadable())
                 {
                     readDataFromSocket(sk);
                 }
                 iterator.remove();
             }
         }
     }

     private static ByteBuffer bb = ByteBuffer.allocate(1024);

     // 从通道中读取数据
     protected static void readDataFromSocket(SelectionKey sk) throws Exception
     {
         SocketChannel sc = (SocketChannel)sk.channel();
         bb.clear();
         while (sc.read(bb) > 0)
         {
             bb.flip();
             while (bb.hasRemaining())
             {
                 System.out.print((char)bb.get());
             }
             System.out.println();
             bb.clear();
         }
     }
 }

2.BIO 多线程实现

 package com.defonds.socket.begin;  

 import java.io.BufferedReader;
 import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.InputStreamReader;
 import java.net.ServerSocket;
 import java.net.Socket;  

 public class Server {
     public static final int PORT = 12345;//监听的端口号     

     public static void main(String[] args) {
         System.out.println("服务器启动...\n");
         Server server = new Server();
         server.init();
     }    

     public void init() {
         try {
             ServerSocket serverSocket = new ServerSocket(PORT);
             while (true) {
                 // 一旦有堵塞, 则表示服务器与客户端获得了连接
                 Socket client = serverSocket.accept();
                 // 处理这次连接
                 new HandlerThread(client);
             }
         } catch (Exception e) {
             System.out.println("服务器异常: " + e.getMessage());
         }
     }    

     private class HandlerThread implements Runnable {
         private Socket socket;
         public HandlerThread(Socket client) {
             socket = client;
             new Thread(this).start();
         }    

         public void run() {
             try {
                 // 读取客户端数据
                 DataInputStream input = new DataInputStream(socket.getInputStream());
                 String clientInputStr = input.readUTF();//这里要注意和客户端输出流的写方法对应,否则会抛 EOFException
                 // 处理客户端数据
                 System.out.println("客户端发过来的内容:" + clientInputStr);    

                 // 向客户端回复信息
                 DataOutputStream out = new DataOutputStream(socket.getOutputStream());
                 System.out.print("请输入:\t");
                 // 发送键盘输入的一行
                 String s = new BufferedReader(new InputStreamReader(System.in)).readLine();
                 out.writeUTF(s);    

                 out.close();
                 input.close();
             } catch (Exception e) {
                 System.out.println("服务器 run 异常: " + e.getMessage());
             } finally {
                 if (socket != null) {
                     try {
                         socket.close();
                     } catch (Exception e) {
                         socket = null;
                         System.out.println("服务端 finally 异常:" + e.getMessage());
                     }
                 }
             }
         }
     }
 }    

基于NIO的服务器相当于把老版本多线程服务器中的read和accept的阻塞时间，都统一集中到了selector.select()里面。当有socket数据过来的时候，selector会选择与当前socket数据对应的一个且已经在其内部注册的channel来执行对应的方法。相当于在老版本多线程服务器中抽象出了一层，这一层就是select方法，这个方法负责接收"任务"以及分发"任务"。

第一种，开多线程可以去接多个请求，防止一个线程的read卡住，无法接收其他客户端的请求。

第二种，把服务提供者全部托管给selector，当有消费任务到来的时候，选择与当前任务适配的服务提供者去提供（而真正的读写操作的阻塞是使用CPU的，真正在"干活"，而且这个过程非常快，属于memory copy，带宽通常在1GB/s级别以上，可以理解为基本不耗时）