BIO网络通信基础（TCP协议）

前言

  BIO是阻塞的IO，阻塞主要是体现在：

• 服务端等待接受客户端的连接。 如果没有客户端连接到达，调用线程会一直挂起，直到有连接到达才返回。
• 服务端等待客户端的请求消息。 如果没有数据可读，或者写缓冲区未就绪，线程会一直等待，直到满足条件。

一、案例工程

  客户端：

public class BIOClient {
    public static void main(String[] args) throws IOException {
        Socket socket = new Socket("localhost", 1848);
        OutputStream out = socket.getOutputStream();
        InputStream in = socket.getInputStream();

        out.write("Hello Server".getBytes());
        out.flush();

        byte[] buffer = new byte[1024];
        int len = in.read(buffer);
        System.out.println("Server Echo: " + new String(buffer, 0, len));

        socket.close();
    }
}

  服务端：

public class BIOServer {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(1848);
        System.out.println("EchoServer started on port 1848");

        //阻塞
        Socket clientSocket = serverSocket.accept();

        handleClient(clientSocket);

    }

    private static void handleClient(Socket clientSocket) {
        try(OutputStream out = clientSocket.getOutputStream();
            InputStream in = clientSocket.getInputStream()){
            byte[] bytes = new byte[1024];
            int len;
            while ((len = in.read(bytes))!= -1){
                out.write(bytes, 0, len);
                out.flush(); // 回显
            }
        }catch (Exception e){
            System.out.println("Client disconnected");
        }

    }
}

  先启动服务端，再启动客户端，运行结果（客户端）：

Server Echo: Hello Server

二、交互流程

  下面是案例工程完整的交互流程：

1. 服务端启动并监听端口 1848。
2. 客户端连接服务端并发送一段数据（“Hello Server”）。
3. 服务端接收数据并将收到的数据原样回写给客户端（回显）。
4. 客户端接收服务端返回的数据并打印。
5. 客户端关闭连接，服务端接收到 read == -1 表示连接断开。

2.1、服务端流程

  监听端口 1848， 阻塞等待客户端连接（accept）

ServerSocket serverSocket = new ServerSocket(1848);
Socket clientSocket = serverSocket.accept(); // 阻塞，直到有客户端连接

  获取输入流/输出流，阻塞读取客户端发来的数据，收到后立即回写

InputStream in = clientSocket.getInputStream();
int len = in.read(bytes); // 阻塞，直到有数据
out.write(bytes, 0, len); // 回显发送

2.2、客户端流程

  主动连接服务端，并且获取输入输出流

Socket socket = new Socket("localhost", 1848);
OutputStream out = socket.getOutputStream();
InputStream in = socket.getInputStream();

  向服务端发送字符串 “Hello Server”

out.write("Hello Server".getBytes());

  读取服务端的回显，会阻塞等待。

byte[] buffer = new byte[1024];
int len = in.read(buffer);
System.out.println("Server Echo: " + new String(buffer, 0, len));

  关闭连接

socket.close();

2.3、 通信过程的详细时序图

客户端                         服务端
  |                               |
  |--------connect(1848)-------->|
  |                               |
  |-----"Hello Server"---------->|
  |                               |
  |<-----"Hello Server"(echo)----|
  |                               |
  |----[关闭连接]---------------->|
  |                               |

  可以通过debug的方式，加深一下关于阻塞的理解，先启动服务端，不启动客户端（模拟没有客户端连接的情况），代码阻塞在accept处：

  但是通过jstack命令，是无法真正判断阻塞的，上图中线程的状态还是Runnable。是因为accept底层调用的本地方法accept0：

  是 C 语言层面的调用，阻塞在 epoll/poll/select 上等待连接；JVM 只是调用了它，并不知道它“卡”住了，所以线程状态是 RUNNABLE。实际上这个线程已经阻塞在线程上下文切换之外（OS 层面），只是 JVM 没法反映出来。
  启动客户端后，服务端接收到连接，解除阻塞，继续向下运行：

  客户端没有发送消息，服务端继续在read处阻塞**（模拟服务端长时间没有接收到客户端的请求）：

  客户端发送消息后，服务端解除了阻塞，同理，服务端没有发出消息前，客户端也会在read处阻塞（模拟客户端长时间没有收到服务端的返回值）**

三、多线程改进版

  最初的案例工程，服务端只能单线程地处理客户端的请求，如果客户端有多个请求，则需要依次执行，所以在实际开发中，会使用线程池的方式进行改进：
  服务端：

public class BIOServer {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(1848);
        System.out.println("EchoServer started on port 1848");

        while (true){
            //阻塞
            Socket clientSocket = serverSocket.accept();
            handleClient(clientSocket);
        }

    }

    private static void handleClient(Socket clientSocket) {
        try(OutputStream out = clientSocket.getOutputStream();
            InputStream in = clientSocket.getInputStream()){
            byte[] bytes = new byte[1024];
            int len;
            while ((len = in.read(bytes))!= -1){
                out.write(bytes, 0, len);
                out.flush(); // 回显
            }
        }catch (Exception e){
            System.out.println("Client disconnected");
        }

    }
}

  客户端：

public class BIOClient {
    public static void main(String[] args) throws IOException {


        clientExec();
        clientExec();
        clientExec();
        clientExec();
        clientExec();


    }

    private static void clientExec() throws IOException {
        Socket socket = new Socket("localhost", 1848);
        OutputStream out = socket.getOutputStream();
        InputStream in = socket.getInputStream();

        out.write(("Hello Server:" + Thread.currentThread().getName()).getBytes());
        out.flush();

        byte[] buffer = new byte[1024];
        int len = in.read(buffer);
        System.out.println("Server Echo: " + new String(buffer, 0, len) + "执行完成");

        socket.close();
    }
}

  运行结果（服务端）：

New client connected,handler threadpool-1-thread-1
New client connected,handler threadpool-1-thread-2
New client connected,handler threadpool-1-thread-3
New client connected,handler threadpool-1-thread-4
New client connected,handler threadpool-1-thread-5

  不难看出，客户端的请求，和服务端的处理，在线程上是1:1的关系，一个客户端的请求，对应的一个服务端的线程去处理。也就是有多少个请求，服务端就要开启多少个线程，而线程的资源是有限的，并且会存在cpu上下文切换的开销。服务器可能直接OOM或频繁GC，无法处理高并发的场景。
  并且BIO 中 in.read() 是阻塞操作，如果客户端长时间不发数据，线程会一直阻塞在那；导致大量线程其实是「空转挂起」状态；

总结

  BIO（Blocking I/O）是阻塞式的网络通信模型，在基于 TCP 协议的实现中，阻塞主要体现在两个阶段：

1. 连接阶段：ServerSocket.accept() 阻塞等待客户端连接；
2. 通信阶段：InputStream.read() 和 OutputStream.write() 阻塞等待数据读写。

  在 BIO 模型中，客户端每建立一个连接，服务端就会创建一个独立线程进行处理，客户端请求与服务端处理呈 1:1 的线程绑定关系。
   「1:1线程-连接模型」是 BIO 的核心瓶颈：当并发连接数上升时，线程资源消耗激增，系统调度压力大，易导致性能下降或资源耗尽。它是一种比较原始的模型，仅适用于学习或低并发业务场景，在高并发生产环境中并不推荐使用。