IO模型之BIO

前言

网络编程的基本模型是C/S模型，即两个进程间的通信。

服务端提供IP和监听端口，客户端通过连接操作想服务端监听的地址发起连接请求，通过三次握手连接，如果连接成功建立，双方就可以通过套接字进行通信。

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

概念

• BIO ，全称 Block-IO ，是一种阻塞 + 同步的通信模式。
• 是一个比较传统的通信方式，模式简单，使用方便。但并发处理能力低，通信耗时，依赖网速。
• 在JDK1.0就存在了

客户端向服务器端发出请求后，客户端会一直等待（不会再做其他事情），直到服务器端返回结果或者网络出现问题。同理服务端也是这样的。

通信模型(原理)

简单的描述一下BIO的服务端通信模型：采用BIO通信模型的服务端，通常由一个独立的Acceptor线程负责监听客户端的连接，它接收到客户端连接请求之后为每个客户端创建一个新的线程进行链路处理没处理完成后，通过输出流返回应答给客户端，线程销毁。即典型的一请求一应答通宵模型。

注： 模型最大的问题就是缺乏弹性伸缩能力，当客户端并发访问量增加后，服务端的线程个数和客户端并发访问数呈1:1的正比关系，Java中的线程也是比较宝贵的系统资源，线程数量快速膨胀后，系统的性能将急剧下降，随着访问量的继续增大，系统最终就死掉了。

BIO体系

就是咱们一直常用的方法

代码展示

普通版

客户端：

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

import com.anxpp.io.utils.Calculator;
/**
 *客户端线程
 *用于处理一个客户端的Socket链路
*/
  public class ServerHandler implements Runnable{
  private Socket socket;
  public ServerHandler(Socket socket) {
    this.socket = socket;
  }
  @Override
  public void run() {
    BufferedReader in = null;
    PrintWriter out = null;
    try{
    in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        out = new PrintWriter(socket.getOutputStream(),true);
        String expression;
        String result;
    while(true){
        //通过BufferedReader读取一行
    //如果已经读到输入流尾部，返回null,退出循环
            //如果得到非空值，就尝试计算结果并返回
            if((expression = in.readLine())==null) break;
            System.out.println("服务器收到消息：" + expression);
            try{
                result = Calculator.cal(expression).toString();
            }catch(Exception e){
            result = "计算错误：" + e.getMessage();
            }
            out.println(result);
        }
    }catch(Exception e){
  
    }finally{
        
        if(in != null){
            try {
                in.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            in = null;
        }
        if(out != null){
            out.close();
            out = null;
        }
        if(socket != null){
            try {
                socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            socket = null;
        }
    }
  }
  }

服务端：

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
/**
 *BIO服务端源码
 *@version 1.0
 */
  public final class ServerNormal {
  //默认的端口号
  private static int DEFAULT_PORT = 12345;
  //单例的ServerSocket
  private static ServerSocket server;
  //根据传入参数设置监听端口，如果没有参数调用以下方法并使用默认值
  public static void start() throws IOException{
    //使用默认值
    start(DEFAULT_PORT);
  }
  //这个方法不会被大量并发访问，不太需要考虑效率，直接进行方法同步就行了
  public synchronized static void start(int port) throws IOException{
    if(server != null) return;
    try{
        //通过构造函数创建ServerSocket
        //如果端口合法且空闲，服务端就监听成功
        server = new ServerSocket(port);
        System.out.println("服务器已启动，端口号：" + port);
        //通过无线循环监听客户端连接
        //如果没有客户端接入，将阻塞在accept操作上。
        while(true){
        Socket socket = server.accept();
            //当有新的客户端接入时，会执行下面的代码
            //然后创建一个新的线程处理这条Socket链路
            new Thread(new ServerHandler(socket)).start();
        }
    }finally{
        //一些必要的清理工作
        if(server != null){
            System.out.println("服务器已关闭。");
            server.close();
            server = null;
        }
    }
  }
  }

以上代码，很容易看出，BIO主要的问题在于每当有一个新的客户端请求接入时，服务端必须创建一个新的线程来处理这条链路，在需要满足高性能、高并发的场景是没法应用的（大量创建新的线程会严重影响服务器性能，甚至罢工）。

伪异步优化版

/**

- BIO服务端源码__伪异步I/O
- @version 1.0
  */
  public final class ServerBetter {
  //默认的端口号
  private static int DEFAULT_PORT = 12345;
  //单例的ServerSocket
  private static ServerSocket server;
  //线程池 懒汉式的单例
  private static ExecutorService executorService = Executors.newFixedThreadPool(60);
  //根据传入参数设置监听端口，如果没有参数调用以下方法并使用默认值
  public static void start() throws IOException{
    //使用默认值
    start(DEFAULT_PORT);
  }
  //这个方法不会被大量并发访问，不太需要考虑效率，直接进行方法同步就行了
  public synchronized static void start(int port) throws IOException{
    if(server != null) return;
    try{
        //通过构造函数创建ServerSocket
        //如果端口合法且空闲，服务端就监听成功
        server = new ServerSocket(port);
        System.out.println("服务器已启动，端口号：" + port);
        //通过无线循环监听客户端连接
        //如果没有客户端接入，将阻塞在accept操作上。
        while(true){
        Socket socket = server.accept();
            //当有新的客户端接入时，会执行下面的代码
            //然后创建一个新的线程处理这条Socket链路
            executorService.execute(new ServerHandler(socket));
        }
    }finally{
        //一些必要的清理工作
        if(server != null){
            System.out.println("服务器已关闭。");
            server.close();
            server = null;
        }
    }
  }
  }

• 线程池，进行IO操作的时候，从线程池中分配一个线程去执行run任务；
• 线程池只提供固定线程，当需求量超过固定线程的时候，则进行等待；

小结

BIO模型是最早的jdk提供的一种处理网络连接请求的模型，是同步阻塞结构，适用于请求量较小，相应比较快的场景。