JavaBIO基本使用以及阻塞问题分析

简单认识BIO

BIO在网络编程中指的是同步阻塞的网络模型（Blocking IO），Java中BIO一般就是我们使用java.io包下提供的一些用来实现网络编程的方法。

---

单线程代码演示

服务端

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;

public class SocketBIO {
    public static void main(String[] args) throws Exception {
        ServerSocket serverSocket = new ServerSocket(9090);
        System.out.println("<服务端启动>");
        while (true) {
            Socket socket = serverSocket.accept();
            System.out.println("---接受客户端连接请求---");
            InputStream inputStream = socket.getInputStream();
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
            while (true) {
            	System.out.println("*等待客户端发送数据*");
                String readLine = bufferedReader.readLine();
                if (readLine.equals("quit")) {
                    System.out.println("---客户端下线---");
                    bufferedReader.close();
                    inputStream.close();
                    socket.close();
                    break;
                } else {
                    System.out.println("接收到客户端发送的数据:" + readLine);
                }
            }
        }
    }
}

客户端

import java.io.*;
import java.net.Socket;

public class SocketBIOCli {
    public static void main(String[] args) throws Exception {
        Socket socket = new Socket("localhost", 9090);
        System.out.println("客户端启动...");
        OutputStream outputStream = socket.getOutputStream();
        BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        while (true) {
            String readLine = reader.readLine();
            if (readLine.equals("quit")) {
                bufferedWriter.write(readLine);
                bufferedWriter.newLine();
                bufferedWriter.flush();
                System.exit(-1);
            } else {
                bufferedWriter.write(readLine);
                bufferedWriter.newLine();
                bufferedWriter.flush();
            }
        }
    }
}

一段非常简单的服务端与客户端的demo，服务端启动监听9090端口，并且当有客户端到来时开始无限循环读取客户端发送的请求数据。
客户端通过从System.in中获取数据并推送到服务端。

启动服务端

首先第一个现象产生，从服务端代码中可以看出来，当前应该是阻塞在accept()这个方法上。

Socket socket = serverSocket.accept();

接着启动客户端

再看服务端

accept方法已经执行完成，但是很明显此时又阻塞在readLine()方法中。

String readLine = bufferedReader.readLine();

客户端发送数据

服务端收到数据

此时我再启动第二个客户端，并向服务端发送数据，但是发现服务端并没有任何响应

接着当我退出第一个客户端时再看服务端响应信息

服务端接受了新的客户端请求，并打印出了之前未响应的新的客户端发送过来的数据。

通过这个小案例可以看出，一个服务端一次只能处理一个客户端的请求，当有多个客户端请求到来时，其他客户端必须等待。

---

多线程版

服务端

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;

public class SocketMultiBIO {
    public static void main(String[] args) throws Exception {
        ServerSocket serverSocket = new ServerSocket(9090);
        System.out.println("<服务端启动>");
        while (true) {
            Socket socket = serverSocket.accept();
            System.out.println("---接受客户端连接请求---");
            new Thread(() -> {
                InputStream inputStream;
                try {
                    inputStream = socket.getInputStream();
                    BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
                    while (true) {
                        System.out.println("*等待客户端发送数据*");
                        String readLine = bufferedReader.readLine();
                        if (readLine.equals("quit")) {
                            System.out.println("---客户端下线---");
                            bufferedReader.close();
                            inputStream.close();
                            socket.close();
                            break;
                        } else {
                            System.out.println("接收到客户端发送的数据:" + readLine);
                        }
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

客户端代码不用修改，此时当启动多个客户端时，服务端已经可以一起处理了。

多线程实际上就是每来一个客户端请求，就丢给一个单独的线程去处理，主线程只负责等待客户端的请求到来

换言之，就是每当有一个新的客户端到来时，服务端就会启动一个线程，这样做有问题吗？

服务端不断的创建线程肯定是存在问题的

1. 线程频繁的创建与销毁，带来的一定的消耗，当然这个问题可以通过线程池来解决。
2. 在IO业务中的线程一般与CPU核心数保持相一致即可，否则线程之间的上下文切换会额外增加系统的响应时间。

总的来说，线程的数量一定是需要严格控制的，当客户端到达一定数量时，服务端任然只能处理部分客户端的请求，其余的只能等待。

BIO的问题

通过上面两个小案例，大家现在应该对BIO有了初步的认识，服务端在整个过程中一共有两处需要产生阻塞：

• 服务端等待客户端连接到来时，对应方法：accept()
• 服务端等待客户端数据到来时，对应方法：readLine()

正是因为这个原因，即使当你使用了多线程时也无法改变客户端连接限制的问题

什么同步阻塞？

在网络模型中，阻塞可以简单的理解为，当数据未到达之前，你是否还能做其他事情？如果可以就是非阻塞的，如果不可以就是阻塞的。
而同步指的是，当数据到来时，你是否还需要调用read方法去主动获取，如果需要就是同步的，如果不需要就是异步的。

在目前的linux内核中，并没有为我们提供异步的方法，也就是说基于linux服务器上运行的应用程序是没有异步非阻塞这样的模型的。

结合上面的案例中，accept需要阻塞等待，线程不能做其他事情，readLine方法需要阻塞等待，并且也是我们主动发起调用的，所以属于同步阻塞模型。

Linux上看阻塞状态

启动服务并相关的追踪系统调用

此时客户端未启动，看一下服务端卡在哪个状态？

我这边版本是JDK1.8的，如果你用JDK1.5或者之前的版本会看到最终卡在accept上，道理是一样的。

启动客户端之后

poll方法之后，服务端调用了accept方法，接受了客户端的连接，并且又卡在了recvfrom方法上，这是在等待客户端的数据到来。

客户端发送数据

再看追踪日志

之前的recvfrom接受到了123456，并且继续调用recvfrom，再次等待数据到来。

---

总结

现在你应该对BIO有了一定的认识，并且也应该能够体会到BIO的问题所在，正是由于阻塞的问题导致了BIO无法突破这个性能瓶颈，所以自然而然的就出现了同步非阻塞模型，以及通过同步非阻塞模型中进一步优化出来了多路复用器模型。