BIO编程参考

超、凢脫俗 2021-09-20 17:04 350阅读 0赞

网络编程的基本模型是Client/Server模型，也就是两个进程之间进行相互通信，其中服务端提供位置信息（绑定的IP地址和监听端口），客户端通过连接操作向服务端监听的地址发起连接请求, 通过三 次握手建立连接, 如果连接建立成功, 双方就可以通过网络套接字 ( Socket) 进行通信。

在基于传统同步阻塞模型开发中, ServerSocket负责绑定 IP 地址, 启动监听端口；Socket负责发起连接操作。连接成功之后, 双方通过输入和输出流进行同步阻塞式通信。

### Bl〇通信模型 ###

采用BIO通信模型的服务端, 通常由一个独立的Acceptor线程负责监听客户端的连接 ,当它接收到客户端连接请求之后，会为每个客户端创建一个新的线程进行链路处理, 处理完成之后, 通过输出流返回应答给客户端, 最后销毁线程，这就是典型的一请求一应答通信模型。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1ZW1lbmdydWkxMg_size_16_color_FFFFFF_t_70][]

BIO最大的问题就是缺乏弹性伸缩能力,每当有一个新的客户端请求接入时, 服务端必须创建一个新的线程处理新接入的客户端链路, 一个线程只能处理一个客户端连接。 当客户端并发访问量增加后, 服务端的线程个数和客户端并发访问数呈1：1的正比关系,由于线程是Java虚拟机珍贵的系统资源, 当线程数剧增之后, 系统的性能将急剧下降, 随着并发访问量的继续增大, 系统会发生线程堆栈溢出、创建新线程失败等问题 , 并最终导致进程宕机或僵死，不能对外提供服务 。而在高性能服务器应用领域,往往需要面向成干上万个客户端的并发连接,这种模型显然正法满足高性能、高并发接入的场景 。

下面我们通过一个案例来说明同步阻塞IO的弊端

public class BioServer {
    
        public static void main(String[] args) throws IOException{
            int port = 8080;
            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 bio server is start in port :"+port);
                Socket socket = null;
                while (true){
                    socket = server.accept();
                    new Thread(new BioserverHandler(socket)).start();
                }
            }finally {
                if(server!=null){
                    System.out.println("the time server close");
                    server.close();
                    server = null;
                }
            }
        }
    }

BioServer根据传入的参数设置监听端口,如果没有,使用默认值8080。然后new一个ServerSocket, 如果端口合法且没有被占用, 服务端监听成功 。通过一个无限循环来监听客户端的连接, 如果没有客户端接入，则主线程阻塞在ServerSocket的accept操作上。当有新的客户端接入的时候,以 Socket为参数构造 BioServerHandler对象, BioServerHandler 是 一个 Runnable, 使用它为构造函数的参数创建一个新的客户端线程处理这条 socket链路，下面是BioServerHandler代码：

public class BioServerHandler implements Runnable {
    
        private Socket socket;
        public BioServerHandler(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 body = null;
                while(true){
                    body = in.readLine();
                    if(body == null){
                        break;
                    }
                    System.out.print("The bio server receive :"+body);
                    out.println(new Date());
                }
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                try {
                    if(in!=null)
                        in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                if(out != null){
                    out.close();
                    out=null;
                }
               if(this.socket != null){
                   try {
                       this.socket.close();
                   } catch (IOException e) {
                       e.printStackTrace();
                   }
                   this.socket = null;
               }
            }
        }
    }

BioClient类

客户端创建Socket连接，向服务器发送消息，然后读取服务器发送的消息， 随后关闭连接，释放资源，退出程序。

public class BioClient {
        public static void main(String[] args){
            Socket socket = null;
            BufferedReader in = null;
            PrintWriter out = null;
            try{
    //            socket.connect(new InetSocketAddress("localhost", 8000));
                socket = new Socket("127.0.0.1",8080);
                out = new PrintWriter(socket.getOutputStream(),true);
                out.println("hello server !!");
                out.flush();
                System.out.println(" send msg to server succeed");
                in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
                String resp = in.readLine();
                System.out.println("receiver from server : " +resp);
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                if(socket != null){
                    try {
                        socket.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                    socket = null;
                }
                if(out != null){
                    out.close();
                    out = null;
                }
                if(in!=null){
                    try {
                        in.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                    in = null;
                }
            }
        }
    }

代码在这了，大家可以自己跑下效果，我想大家在学习socket编程的时候，估计这样的demo都写烂了，好了，不说什么了

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1ZW1lbmdydWkxMg_size_16_color_FFFFFF_t_70]: /images/20210920/d03b73ca66a948d582078376c8a47280.png