当遇到并发服务场景时，咱们能够采取如下措施:

一、同步阻塞IO实现

public class DemoServer extends Thread {
    private ServerSocket serverSocket;


    public int getPort() {
        return serverSocket.getLocalPort();
    }


    public void run() {
        try {
            serverSocket = new ServerSocket(0);
            while (true) {
                // 十分占用内存资源，每个客户端启用一个线程，非常不合理
                Socket socket = serverSocket.accept();
                RequesHandler requesHandler = new RequesHandler(socket);
                requesHandler.start();
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (serverSocket != null) {
                try {
                    serverSocket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                ;
            }
        }
    }


    public static void main(String[] args) throws IOException {
        DemoServer server = new DemoServer();
        server.start();
        try (Socket client = new Socket(InetAddress.getLocalHost(), server.getPort())) {
            BufferedReader buferedReader = new BufferedReader(new InputStreamReader(client.getInputStream()));
            buferedReader.lines().forEach(s -> System.out.println(s));
        }
    }
}

// 简化实现，不做读取，间接发送字符串
class RequesHandler extends Thread {
    private Socket socket;


    RequesHandler(Socket socket) {
        this.socket = socket;
    }


    @Override
    public void run() {
        try (PrintWriter out = new PrintWriter(socket.getOutputStream());) {
            out.println("Hello world!");
            out.flush();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

每次 new 一个线程或者销毁一个线程是有显著的开销的，每个线程都有独自的线程构造，十分占用内存资源，每个客户端启用一个线程是非常不合理的， 因而能够采纳线程池的形式进行优化。

// 也是阻塞IO，采纳线程池的形式解决申请，当来一个新的客户端连贯时，
// 将申请 Socket 封装成一个 task ，放到线程池中取执行。

serverSocket = new ServerSocket(0);
executor = Executors.newFixedThreadPool(8);
while (true) {
    Socket socket = serverSocket.accept();
    RequesHandler requesHandler = new RequesHandler(socket);
    executor.execute(requesHandler);
}

二、NIO实现

NIO（非阻塞IO） 多路复用机制

public class NIOServer extends Thread {
    public void run() {
        try (Selector selector = Selector.open(); ServerSocketChannel serverSocket = ServerSocketChannel.open();) {// 创立Selector和Channel
            serverSocket.bind(new InetSocketAddress(InetAddress.getLocalHost(), 8888));
            serverSocket.configureBlocking(false);
            // 注册到Selector，并阐明关注点
            serverSocket.register(selector, SelectionKey.OP_ACCEPT);
            while (true) {
                selector.select();// 阻塞期待就绪的Channel，这是关键点之一
                Set<SelectionKey> selectedKeys = selector.selectedKeys();
                Iterator<SelectionKey> iter = selectedKeys.iterator();
                while (iter.hasNext()) {
                    SelectionKey key = iter.next();
                    // 生产零碎中个别会额定进行就绪状态查看
                    sayHelloWorld((ServerSocketChannel) key.channel());
                    iter.remove();
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }


    private void sayHelloWorld(ServerSocketChannel server) throws IOException {
        try (SocketChannel client = server.accept();) {
            ByteBuffer readBuffer = ByteBuffer.allocate(32);
            client.read(readBuffer);
            System.out.println("Server received : " + new String(readBuffer.array()));
            ByteBuffer writeBuffer = ByteBuffer.allocate(128);
            writeBuffer.put("hello xiaoming".getBytes());
            writeBuffer.flip();
            client.write(writeBuffer);
            //client.write(Charset.defaultCharset().encode("Hello world!"));
        }
    }


    public static void main(String[] args) throws IOException {
        NIOServer server = new NIOServer();
        server.start();
        
        try {
            SocketChannel socketChannel = SocketChannel.open();
            socketChannel.connect(new InetSocketAddress(InetAddress.getLocalHost(), 8888));


            ByteBuffer writeBuffer = ByteBuffer.allocate(32);
            ByteBuffer readBuffer = ByteBuffer.allocate(32);


            writeBuffer.put("hello".getBytes());
            writeBuffer.flip();


            while (true) {
                writeBuffer.rewind();
                socketChannel.write(writeBuffer);
//                readBuffer.clear();
                socketChannel.read(readBuffer);
                System.out.println("Client received : " + new String(readBuffer.array()));
            }
        } catch (IOException e) {
        }
        
    }

/**
 * @return
 */
private int getPort() {
    return 8888;
}

三、总结

在后面两个例子中:阻塞IO和伪异步IO，一个是应用 new 线程的形式，另外一个是采纳线程池治理的形式， IO都是同步阻塞模式，所以须要多线程以实现多任务处理。

而 NIO 则是利用了单线程轮询事件的机制，通过高效地定位就绪的Channel，来决定做什么，仅仅select阶段是阻塞的，能够无效防止大量客户端连贯时频繁线程切换带来的问题，利用的扩大能力有了十分大的进步。