Java 传统的socket连接以及使用线程池连接

public class TestServer {

    public static void main(String[] args) {
        try {
            ServerSocket socket = new ServerSocket(11111);
            while (true) {
                //监听连接
                Socket socket1 = socket.accept();
                //新建一条线程去处理数据
                new Thread(new TestServerHanlder(socket1)).start();
                //使用线程池的方式去做处理
                TestServerHandlerExcutePool pool = new TestServerHandlerExcutePool(100, 100);
                pool.execute(new TestServerHanlder(socket1));
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

public class TestServerHanlder implements Runnable {

    private Socket socket;

    public TestServerHanlder(Socket socket) {
        this.socket = socket;
    }

    public void run() {
        BufferedReader in = null;
        PrintWriter out = null;
        try {
            in = new BufferedReader(new InputStreamReader(this.socket.getInputStream()));
            out = new PrintWriter(this.socket.getOutputStream(), true);
            String body = null;
            while (true) {
                body = in.readLine();
                if (StringUtils.isBlank(body)) {
                    break;
                }
                System.out.println("this is a test");
            }
        } catch (Exception ex) {

        }


    }
}

　　

public class TestServerHandlerExcutePool {

    private ExecutorService service = null;

    public TestServerHandlerExcutePool(int maxPoolSize, int queueSize) {
        service = new ThreadPoolExecutor(Runtime.getRuntime().availableProcessors(), maxPoolSize,
                120L, TimeUnit.SECONDS, new ArrayBlockingQueue<>(queueSize));
    }

    public void execute(Runnable task) {
        service.execute(task);
    }
}

传统的io流是阻塞式的，假如多条线程请求同一个数据，会导致阻塞，如下图api说明：