从零开始netty学习笔记之BIO

BIO即Block IO，阻塞式IO。
网络编程的基本模型是Client/Server模型，也就是两个进程之间进行相互通信，其中服务端提供位置信息（绑定的IP地址和监听端口），客户端通过连接操作向服务端监听的地址发起连接请求，通过三次握手建立连接，如果连接建立成功，双方就可以通过网络套接字（Socket）进行通信。
在基于传统同步阻塞模型开发中，ServerSocket负责绑定IP地址，启动监听端口：Socket负责发起连接操作。连接成功之后，双方通过输入和输出流进行同步阻塞式通信。

传统阻塞式IO

BIO服务端通信模型：采用BIO通信模型的服务端，通常由一个独立的Acceptor线程负责监听客户端的连接，它接收到客户端连接请求之后为每个客户端创建一个新的线程进行链路处理，处理完之后，通过输出流返回应答给客户端，线程销毁。
该模型最大的问题就是缺乏弹性伸缩能力，当客户端并发访问量则增加后，服务端的线程个数和客户端并发访问数呈1：1的正比关系，由于线程是java虚拟机非常宝贵的系统资源，当线程数膨胀之后，系统的性能 将急剧下降，随着并发访问量的继续增大，系统会发生线程堆栈溢出、创建新线程失败等问题，并最终导致进程宕机或者僵死，不能对外提供服务。
传统的BIO
代码演示：
服务端

public class TimeServer {

    public static void main(String[] args) {

        int port = 8081;
        if(args!=null&&args.length>0){
            try{
                port = Integer.valueOf(args[0]);
            }catch (Exception e){
                e.printStackTrace();
            }
        }
        ServerSocket serverSocket = null;
        try{
            serverSocket = new ServerSocket(port);
            System.out.println("服务器已经启动--端口号："+port);
            Socket socket = null;
            while (true){
                socket = serverSocket.accept();
                new Thread(new TimeServerHandler(socket)).start();
            }

        }catch (Exception e){
            e.printStackTrace();
        }finally {
            if(serverSocket!=null){
                System.out.println("服务器关闭");
                try{
                    serverSocket.close();
                }catch (Exception e1){
                    e1.printStackTrace();
                }
                serverSocket = null;
            }
        }
    }
}

服务端处理器

public class TimeServerHandler implements Runnable {

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


    private Socket socket;


    @Override
    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 currentTime = null;
            String body = null;
            while(true){
                body = in.readLine();
                if(body == null){
                    break;
                }
                System.out.println("服务器收到消息："+body);
                currentTime = "QUERY TIME ORDER".equalsIgnoreCase(body)? new Date(System.currentTimeMillis()).toString():"BAD ORDER";
                out.println(currentTime);
            }

        }catch (Exception e){
            e.printStackTrace();
            if(in!=null){
                try{
                    in.close();
                }catch (Exception e1){
                    e1.printStackTrace();
                }
            }
            if(out!=null){
                out.close();
                out = null;
            }
            if(this.socket!=null){
                try{
                    this.socket.close();
                }catch (Exception e1){
                    e.printStackTrace();
                }
                this.socket = null;
            }
        }

    }
}

客户端

public class TimeClient {

    public static void main(String[] args) {

        int port = 8081;
        if(args!=null&&args.length>0){
            try{
                port = Integer.valueOf(args[0]);
            }catch (Exception e){
                e.printStackTrace();
            }

        }
        Socket socket = null;
        BufferedReader in = null;
        PrintWriter out  = null;
        try{
            socket = new Socket("127.0.0.1",port);
            in  = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            out = new PrintWriter(socket.getOutputStream(),true);
            out.println("QUERY TIME ORDER");
            System.out.println("发送命令成功");
            String resp = in.readLine();
            System.out.println("收到的消息："+resp);
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            if(out!=null){
                out.close();
                out = null;
            }
            if(in!= null){
                try{
                    in.close();
                }catch (Exception e2){
                    e2.printStackTrace();
                }
                in = null;
            }
            if(socket!= null){
                try{
                    socket.close();
                }catch (Exception e2){
                    e2.printStackTrace();
                }
                socket = null;
            }
        }
    }
}

57D68050-8C99-40EE-8760-18878851D2D7.png

55CC2938-2F41-4307-A8FF-265BF1165DE7.png

传统的BIO每当一个新的客户端请求接入时，服务端必须创建一个新的线程处理接入的客户端链路，一个线程只能处理一个客户端连接。在高性能服务器应用领域，往往需要面向成千上万个客户端的并发连接，所以这种模型肯定无法满足高性能高并发的 场景。

伪异步IO编程

伪异步的原理就是后端通过一个线程池来处理过个客户端的请求接入，形成客户端个数M：线程池最大线程数N的比例关系，其中M可以远远大于N。通过线程池可以灵活的调配线程资源，设置线程的最大值，防止由于海量并发接入导致线程耗尽。

具体实现：当有新的客户端接入时，将客户端的Socket封装成一个Task（该任务实现Runnable接口）投递到后端的线程池中进行处理，JDK的线程池维护一个消息队列和N个活跃线程，对消息队列中的任务进行处理。由于线程池可以设置消息队列的大小和最大线程数，因此，它的资源占用是可控的，无论多少个客户端并发访问，都不会导致资源的耗尽和宕机。
代码演示：
线程池

public class TimeServerHandlerExecutePool {

    private ExecutorService executorService;

    public TimeServerHandlerExecutePool(int maxPoolSize,int queueSize){

        this.executorService = new ThreadPoolExecutor(Runtime.getRuntime().availableProcessors(),
                maxPoolSize,120L, TimeUnit.SECONDS,new ArrayBlockingQueue(queueSize));
    }
    public void execute(Runnable task){
        executorService.execute(task);
    }
}

server代码和原来差不多，只是将原来的创建线程改为使用线程池来执行这个任务。

 serverSocket = new ServerSocket(port);
            System.out.println("服务器已经启动--端口号："+port);
            Socket socket = null;
            TimeServerHandlerExecutePool  singleExecutor = new TimeServerHandlerExecutePool(50,10000);//创建IO任务线程池
            while (true){
                socket = serverSocket.accept();
                singleExecutor.execute(new TimeServerHandler(socket));

            }

伪异步IO弊端分析：
read
当对Socket的输入流进行读取操作的时候，它会一直阻塞下去，知道发生如下三种事件。

• 有数据可读
• 可用数据已经读取完毕
• 发生空指针异常或者IO异常
  这意味着当对方发送请求或者应答消息比较缓慢，或者网络传输较慢时，读取输入流一方的通信线程将被长时间阻塞，如果对方要60s才能够将数据发送完毕，读取一方的IO线程也将被同步阻塞60s，在此期间，其他接入消息只能在消息队列中排队。
  write
  当调用OutputStream的write方法写输出流的时候，它将会被阻塞，知道所有要发送的字节全部写入完毕，或者发生异常。学习过TCP/IP相关知识的人都知道，当消息的接收方处理缓慢的时候，将不能及时的从TCP缓冲区读取数据，这将会导致发送方的TCP window size不断减少，知道为0，双方处于Keep-Alive状态，消息发送方将不能再向TCP缓冲区写入消息，这时如果采用的是同步阻塞IO，write操作将会被无线阻塞，知道TCP window size大于0或者发生IO异常。

通过对输入和输出流的API进行分析，读和写操作都是同步阻塞的，阻塞的时间取决于对方对方IO线程的处理速度和网络IO的传输速度。本质上来讲，我们无法保证生产环境的网络状况和对端的应用程序能足够快，如果我们的应用程序依赖对方的处理速度，它的可靠性就非常差。