伪异步I/O编程-笔记2

伪异步I/O编程

标签（空格分隔）： I/O

---

------在简单的客户端服务端交流案例中，客户端的并发访问增加时，服务端将呈现1:1的线程开销，访问量越大，系统将发生线程栈溢出，线程创建失败，最终导致进程宕机或者僵死，从而不能对外提供服务。
------我们需要一个伪异步I/O的通信框架，通过线程池和任务队列实现。
------当客户端接入时，将客户端的Socket封装成一个Task（该任务实现java.lang.Runnable线程任务接口）交给后端的线程池中进行处理。JDK的线程池维护一个消息队列和N个活跃的线程，对消息队列中Socket任务进行处理，由于线程池可以设置消息队列的大小和最大线程数，因此，它的资源占用是可控的，无论多少个客户端并发访问，都不会导致资源的耗尽和宕机。

package com.allwinter.four;

import java.net.ServerSocket;
import java.net.Socket;

/**
 * 开发伪异步通信架构
 */
public class Server {
    public static void main(String[] args) {
        try {
            //注册端口
            ServerSocket ss = new ServerSocket(9999);
            //初始化一个线程池对象
            HandlerSocketServerPool pool = new HandlerSocketServerPool(3,10);
            while(true){
                Socket socket = ss.accept();
                //把socket对象交给一个线程池进行处理
                //把Socket封装成一个任务对象交给线程池处理
                Runnable target = new ServerRunnableTarget(socket);
                pool.execute(target);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}

package com.allwinter.four;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;


public class HandlerSocketServerPool {
    //创建一个线程池的成员变量用于存储一个线程池对象
    private ExecutorService executorService;

    /**
     * 创建这个类的对象的时候就需要初始化线程池对象
     *  public ThreadPoolExecutor(int corePoolSize,
     *                               int maximumPoolSize,
     *                               long keepAliveTime,
     *                               TimeUnit unit,
     *                               BlockingQueue<Runnable> workQueue)
     */

    public HandlerSocketServerPool(int maxThreadNum, int queueSize){
        executorService = new ThreadPoolExecutor(3,maxThreadNum,120, TimeUnit.SECONDS,new ArrayBlockingQueue<Runnable>(queueSize));
    }

    /**
     * 提供一个方法来提交任务给线程池的任务队列来暂存，等着线程池来处理
     */
    public void execute(Runnable target){
        executorService.execute(target);
    }
}

package com.allwinter.four;

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

public class ServerRunnableTarget implements Runnable {
    private Socket socket;
    public ServerRunnableTarget(Socket socket){
        this.socket = socket;
    }
    @Override
    public void run() {
        // 处理接受到的客户端Socket通信需求
        try {
            InputStream is = socket.getInputStream();
            BufferedReader br = new BufferedReader(new InputStreamReader(is));
            String msg;
            while ((msg = br.readLine()) != null){
                System.out.println("Server get msg : " + msg);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

package com.allwinter.four;

import java.io.IOException;
import java.io.PrintStream;
import java.net.Socket;
import java.util.Scanner;


public class Client {
    public static void main(String[] args) {
        try {
            Socket socket = new Socket("127.0.0.1",9999);
            PrintStream ps = new PrintStream(socket.getOutputStream());
            Scanner input = new Scanner(System.in);
            String msg = null;
            while (!"exit".equals(msg)){
                System.out.print("client input : ");
                msg = input.nextLine();
                ps.println(msg);
                ps.flush();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

1. 伪异步IO采用了线程池实现，因此避免了为每个请求创建一个独立线程造成线程资源耗尽的问题，但底层已然是采用的同步阻塞模型，因此无法从根本上解决问题。
2. 如果点那个消息处理的缓慢，或者服务器线程池中的全部线程都被阻塞，那摸后续socket的I/O消息都将在队列中排队。新的Socket请求将被拒绝，客户端会发生大量连接超时。