基于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("服务器启动...
");    
        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("请输入:	");    
                // 发送键盘输入的一行    
                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级别以上，可以理解为基本不耗时）