java-多线程(线程池)阻塞IO模型案例

 单线程阻塞IO模型(单条执行路径)每次只能处理一个连接，后面的连接被阻塞掉，需要前面的连接退出后，服务器才能处理下一个连接请求。

这种模型没有意义。为解决该问题可以使用多线程（多线程就是多条执行路径）。每次有新的连接就创建一个新的线程处理该连接，即一个连接对应一个线程。

使用多线程，系统不断的启动和关闭新线程，增加了系统的调度和开销,效率低下。为进一步提高服务器工作效率，一般需要采用线程池。

当服务器接收到新的连接时，将它交给线程池。如果线程池内有空闲线程，线程池将其交给该空闲线程处理。如果没有空闲线程，则只能继续等待处理。

 

package com.day0519;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @author: 
 * @Date: 2020/05/15
 * @Description:
 */
public class ServerSocketListener {

    public static void main(String[] args) throws IOException {
        // 创建一个可重用固定线程数的线程池，以共享的无界队列方式来运行这些线程。
        ExecutorService pool = Executors.newFixedThreadPool(20);
        ServerSocket serverSocket = new ServerSocket(9698);
        while (true) {
            Socket clientSocket = serverSocket.accept();
            // 执行给定的任务，当所有任务完成时，返回保持任务状态和结果的 Future 列表。
            // 将新的连接交给ClientHandler处理
            pool.submit(new ClientHandler(clientSocket));
            // 创建的是new Runnable()对象，把对象交给线程池里的某个空闲线程。执行完后，线程释放回到线程池。
            //适用于短连接，不适用于长连接，同样不适用于高并发
        }
    }
}

package com.day0519;

import java.io.*;
import java.net.Socket;

/**
 * @author: 
 * @Date: 2020/05/19
 * @Description:处理连接
 */
public class ClientHandler implements Runnable {

    private Socket socket = null;

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

    @Override
    public void run() {
        System.out.println("client socket connect：" + socket.getRemoteSocketAddress());
        BufferedReader reader = null;
        try {
            reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        } catch (IOException e) {
            e.printStackTrace();
        }
        BufferedWriter writer = null;
        try {
            writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
        } catch (IOException e) {
            e.printStackTrace();
        }
        String readLine;
        try {
            while ((readLine = reader.readLine()) != null) {
                System.out.println("message from client：" + readLine);
                if ("bye".equals(readLine)) {
                    break;
                } else {
                    writer.write(readLine);
                    writer.newLine();
                    writer.flush();
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

package com.day0519;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;

/**
 * @author: 
 * @Date: 2020/05/15
 * @Description:
 */
public class ClientSocket {

    public static void main(String[] args) throws IOException {
        try {
            Socket socket = new Socket("localhost", 9698);
            BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
            PrintWriter writer = new PrintWriter(socket.getOutputStream());
            BufferedReader socketReader  = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            String readLine;
            while ((readLine = reader.readLine()) != null) {
                writer.println(readLine);
                writer.flush();
                System.out.println("message from server：" + socketReader.readLine());
                if (readLine.equals("over")) {
                    break;
                }
            }
            writer.close();
            socketReader.close();
            reader.close();
            socket.close();
        } catch (IOException e) {
            System.out.println("can't listen to:" + e);
        }
    }
}