伪异步I/O编程

采用线程池和任务队列可以实现伪异步I/O编程

实现原理：当客户端接入时，将客户端的Socket封装成一个Task( 该任务实现java.lang.Runable线程任务接口)交给后端的线程池中进行处理。JDK 的线程池维护一个消息队列和 N 个活跃线程，对消息队列中的任务进行处理。由于线程池可以设置消息队列的大小和最大线程数，因此，它的资源占用是可控的，无论多少个客户端并发访问，都不会导致资源的耗尽和宕机。

代码实例：

用伪异步io的方法实现通信

1）首先构建服务器端

//目标：实现伪异步性能架构
//服务端
public class Server {
    public static void main(String[] args) {
        try {
            //1.注册接口
            ServerSocket ss = new ServerSocket(9999);
            //2.定义客户端的连接请求
            //初始化一个线程池对象
            HandlerSocketServerPool pool = new HandlerSocketServerPool(3,10);
            while(true){
                Socket socket = ss.accept();
                //3.把socket封装成任务对象，
               Runnable target = new ServerRunableTarget(socket);
               //交给线程池进行处理
               pool.execute(target);
        }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

2）线程池开发

//线程池开发
public class HandlerSocketServerPool {
    //1.创建一个线程池的成员变量用于储存一个线程池对象
    private ExecutorService executorService;
    //2.创建这个类的时候就要初始化线程池对象，这里传入的最大线程数是3
    public HandlerSocketServerPool(int maxThreadNum , int queueSize){
        executorService = new ThreadPoolExecutor(3,maxThreadNum,120, TimeUnit.SECONDS,new ArrayBlockingQueue<Runnable>(queueSize));
    }
    //3.提供一个方法来提交任务给线程池的任务队列来暂存，等着线程池来处理
    public void execute(Runnable target){
        executorService.execute(target);
    }
}

3）再创建个线程任务对象

//线程任务对象
public class ServerRunableTarget implements Runnable{
    //接收到当前socket
    private Socket socket;
    public ServerRunableTarget(Socket socket){
        this.socket = socket;
    }
    @Override
    public void run() {
        //处理接收到的客户端socket通信需求
        try {
            //从Socket管道中得到一个字节输入流
            InputStream is = socket.getInputStream();
            //使用缓冲字符输入流包装字节输入流
            BufferedReader br= new BufferedReader(new InputStreamReader(is));
            String msg;
            while((msg = br.readLine()) != null){
                System.out.println(msg);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

4）创建客户端

//客户端
public class Client {
    public static void main(String[] args) throws IOException {
        //1.请求与服务器的socket的对象链接
        Socket socket = new Socket("127.0.0.1",9999);
        //2.从Socket对象中获取一个字节对象输出流
        OutputStream os = socket.getOutputStream();
        //3.把字节输出流包装成一个打印流
        PrintStream ps = new PrintStream(os);
        Scanner sc = new Scanner(System.in);
        while(true) {
            System.out.println("请输入：");
            String msg = sc.nextLine();
            ps.println(msg);
            ps.flush();
        }
    }
}

5）以上代码即可完成3名客户对服务端的通信，我们运行一下

小结：

• 伪异步io采用了线程池实现，因此避免了为每个请求创建一个独立的线程造成的资源耗尽的问题，但由底层任然是采用同步堵塞队列，因此无法从根本上解决问题

• 如果单个消息处理的缓慢，或者服务器线程池中的全部变量都被阻塞，那么后续的socket的io消息都将在队列中排队。新的socket请求将被拒绝。客户端会发生大量的连接超时