Linux I/O 与 Java I/O

try {
	ServerSocket serverSocket = new ServerSocket(port);
    while(listening){
        /* Wait for the client to make a connection (blocks) and when it does,
        create a new socket to handle the request */
        Socket socket = serverSocket.accept();

        //1. 服务器单线程处理客户端连接
        /*try{
            PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
            
            BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));

            String request, response;
            
            while((request=in.readLine()) != null){
                response = processRequest(request);
                out.println(response);
                if("Done".equals(request)) break;
            }
        } catch (IOException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
        	  //必须关闭当前连接才能开启下一个
            socket.close();
        }*/

        //2. Handle each connection in a new thread to manage concurrent users
        new Thread(()->{
            try{
                PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
                BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));

                String request, response;
                while((request=in.readLine()) != null){
                    response = processRequest(request);
                    out.println(response);
                    if("Done".equals(request)) break;
                }
                socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }).start();
    }
} catch (IOException e) {
    e.printStackTrace();
}

ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
//非阻塞
serverSocketChannel.configureBlocking(false);
serverSocketChannel.bind(new InetSocketAddress(port));
while(true){
    System.out.println("waiting for connections...");
    // return inmediately because blocking is set to fasle
    // if no incoming connection had arrived, null would be returned
    // 轮询查询是否有 ready 的连接，空转消耗 CPU 资源
    SocketChannel sc = server.accept();
    //如果有 ready 的连接
    if(sc != null){
        System.out.println("Incoming connection from: "
                + sc.socket().getRemoteSocketAddress());
        buffer.clear();
        if(sc.read(buffer) > 0){
            buffer.flip();
            while(buffer.hasRemaining())
                System.out.print((char) buffer.get());
        }
        sc.close();
    }
}

ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
//非阻塞
serverSocketChannel.configureBlocking(false);
serverSocketChannel.bind(new InetSocketAddress(port));
    
// serverSocketChannel is ready for connection
serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
System.out.println("starting server on port >> " + port);
while(true){
    // wait for ready events
    // ready for connection, ready for reading, ready for writing
    // if no event is ready, select blocks, cpu 资源被节省下来
    // 同时，如果多个线程同时进行 I/O 操作，各个线程都不会被阻塞，只有 select 线程会被阻塞
    if(selector.select() == 0) continue;
    Set<SelectionKey> selectKeys = selector.selectedKeys();
    Iterator<SelectionKey> iter = selectKeys.iterator();
    while(iter.hasNext()){
        SelectionKey selectionKey = iter.next();
        if(selectionKey.isAcceptable()){
            // previous registered serverSocketChannel is ready for connection
            ServerSocketChannel server = (ServerSocketChannel) selectionKey.channel();
            // after a client is connected, a new SocketChannel is returned
            SocketChannel client = server.accept();
            client.configureBlocking(false);
            System.out.println("Connected by: " + client.socket().getRemoteSocketAddress());
            // register the socketChannel between server and client to the selector
            client.register(selector, SelectionKey.OP_READ);
        }else if(selectionKey.isReadable()){
            SocketChannel client = (SocketChannel) selectionKey.channel();
            //System.out.println("channel ready for read >>" + client.socket().getRemoteSocketAddress());
            ByteBuffer buffer = ByteBuffer.allocate(8);
            // 当客户端不再传来数据（客户端关闭）时，必须关闭这里的 channel，否则每次 select 后，这个 channel 都会是可读状态
            // channel.close() 内部会调用 selectionKey 的 cancel() 方法，将其从 selector 中取消注册
            if(client.read(buffer) < 0) client.close();
            buffer.flip();
            while(buffer.hasRemaining()){
                System.out.print((char)buffer.get());
            }
        }else if(selectionKey.isWritable()){
            SocketChannel client = (SocketChannel) selectionKey.channel();
            client.write(ByteBuffer.wrap("Server sending message to client...\n".getBytes()));
        }
        // we have to remove the processed ready event from the "ready table"
        // the ready table which returned by calling of selector.selectedKeys() method will not remove
        // the "ready channel" returned by previous call of selector.selectedKeys() method
        iter.remove();
    }
}