netty入门1 bio分析

传统的BIO

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

该模型最大的问题时缺乏弹性伸缩能力，当客户端并发访问量增加后，服务端的线程个数和客户端并发访问数呈1:1的正比关系，由于线程是Java虚拟机非常宝贵的系统资源，当线程数膨胀后，系统性能将急剧下降，随着并发访问量的增大，系统会发生线程堆栈溢出、创建新线程失败等问题，最终导致进程宕机或者僵死，不能对外提供服务。
下面会用2个小节，分别对服务器和客户端进行源码分析，寻找同步阻塞IO的弊端

同步阻塞服务端

package test1;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Date;

public class TimeServer {
    private static int port;
    public static void main(String[] args){
        port=8089;
        if(args!=null&&args.length>0){
            try{
                port=Integer.valueOf(args[0]);
            }catch(NumberFormatException e){

            }
        }

        ServerSocket server=null;
        try{
            server=new ServerSocket(port);
            System.out.println("the time server is start in port:"+port);
            Socket socket=null;
            for (;;){
                socket=server.accept();
                new Thread(new TimeServerHandler(socket)).start();

            }

        }catch(IOException e){

        }finally {
            if(server!=null){
                System.out.println("the time server close");
                try {
                    server.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                server=null;
            }
        }
    }
}

class TimeServerHandler implements Runnable{
    private int port;
    private Socket socket;

    public TimeServerHandler(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 currentTIme=null;
            String body=null;
            for (;;){
                body=in.readLine();
                if (body==null)
                    break;
                    System.out.println("the time server receive order:"+body);
                    currentTIme="QUERY TIME ORDER".equals(body)?new Date(System.currentTimeMillis()).toString():"bad error";
                    out.println(currentTIme);
            }
        }catch (Exception e){
            if(in!=null){
                try{
                    in.close();
                }catch (IOException ex){
                    ex.printStackTrace();
                }
            }
            if (out!=null){
                out.close();
                out=null;
            }
            if(this.socket!=null){
                try{
                    this.socket.close();
                }catch (IOException e1){
                    e1.printStackTrace();
                }
            }
        }
    }
}

TimerServer根据传入的参数设置port监听端口，如果没有传入端口号，默认采用8089；通过new ServerSocket(port)创建一个serversocket，下面再通过死循环来监听客户端的连接，如果客户端没有接入，则主线程阻塞在accept上。
当有新的客户端接入时，构造一个TimeServerHandler对象传入socket来处理这条socket链路。
TimerServerHandler通过BufferReader读取一行，如果已经读取到输入流的尾部，则返回null,退出循环。如果读到非空值，则对内容进行判断，如果请求的消息为查询时间的指令则获取当前最新的系统时间，再通过pringwriter的println发送给客户端，退出循环，最后释放输入流、输出流、套接字socket资源。

同步阻塞客户端

客户端通过socket创建，发送查询时间服务器的指令，然后读取服务端的相应并将结果打印出来，随后关闭链接，释放资源，退出执行。

package test1;

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

public class TimerClient {
    public static void main(String[] args){
        int port=8089;
        if(args!=null&&args.length>0){
            try{
                port=Integer.valueOf(args[0]);
            }catch (NumberFormatException e){

            }
        }

        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");
            String resp=in.readLine();
            System.out.println("now is:"+resp);
        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (out!=null){
                out.close();
            }

                try {

                    if(in!=null) {
                        in.close();
                    }

                    if (socket!=null){
                        socket.close();
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
                socket=null;
        }
    }
}

至此为止，同步阻塞io开发的时间服务器程序已经完毕，我们发现主要的问题在于每当有一个新的客户端请求接入时，服务端必须创建一个新的线程处理新接入的客户端链路，一个线程只能处理一个客户端链接。在高性能服务器领域，往往需要面对成千上万个客户端的并发链接，这种模型显然无法满足高性能的要求。
为了改进一线程一链接模型，后来又演进出了一种通过线程池或者消息队列实现1个或者多个线程处理N个客户端的模型，由于它的底层通信机制依然使用同步阻塞IO，所以被称为伪异步。