一、BIO简介
BIO是java1.4之前唯一的IO逻辑，在客户端通过socket向服务端传输数据，服务端监听端口。由于传统IO读数据的时候如果数据没有传达，IO会一直等待输入传入，所以当有请求过来的时候，新起一条线程对数据进行等待、处理，导致每一个链接都对应着服务器的一个线程。
BIO是同步阻塞的，如图所示：
二、原理简述
BIO对应linux io模型的阻塞IO，服务端提供IP和监听端口，客户端通过连接操作想服务端监听的地址发起连接请求，通过三次握手连接，如果连接成功建立，双方就可以通过套接字进行通信。
重要组件
ServerSocket：负责绑定IP地址，启动监听端口
Socket：负责发起连接操作。连接成功后，双方通过输入和输出流进行同步阻塞式通信。
三、手写服务端
首先我们来用ServerSocket和Socket写个服务端，并进行测试，代码以及注释如下：
public class BioServerSingle { //blocking
public static void main(String[] args) {
// 服务端开启一个端口进行监听
int port = 8080;
ServerSocket serverSocket = null; //服务端
Socket socket; //客户端
InputStream in = null;
OutputStream out = null;
try {
serverSocket = new ServerSocket(port); //通过构造函数创建ServerSocket，指定监听端口，如果端口合法且空闲，服务器就会监听成功
// 通过无限循环监听客户端连接，如果没有客户端接入，则会阻塞在accept操作
while (true) {
System.out.println("Waiting for a new Socket to establish" + " ," + new Date().toString());
socket = serverSocket.accept();//阻塞 三次握手
in = socket.getInputStream();
byte[] buffer = new byte[1024];
int length = 0;
while ((length = in.read(buffer)) > 0) {//阻塞
System.out.println("input is:" + new String(buffer, 0, length) + " ," + new Date().toString());
out = socket.getOutputStream();
out.write("success".getBytes());
System.out.println("Server end" + " ," + new Date().toString());
}
}
} catch (Exception e) {
e.printStackTrace();
} finally {
// 必要的清理活动
if (serverSocket != null) {
try {
serverSocket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (in != null) {
try {
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (out != null) {
try {
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
执行代码main方法启动服务端，并查看堆栈信息，可以看到服务端阻塞在ServerSocket的accept方法，如截图：
此处即是ServerSocket的第一个阻塞点，接下来在控制台执行命令：
telnet localhost 8080
打印此时堆栈信息可以看到ServerSocket阻塞在read方法，如截图所示：
如果此时在控制台输入一些内容，那么服务端将接收到控制台输入，并会成功将服务端想要输出的的内容返回给控制台，如图所示：
如图所示，这样就完成了一次socket的连接与数据传输，但是这样的Socket并未关闭，你仍旧可以继续在控制台输入内容，然后服务端接收输入，因为这一次的Socket并未关闭，从哪里可以看出来呢？
如图所示：执行的代码并未重新等待一次新的Socket客户端请求，而且原先的Socket客户端（即控制台）仍旧可以继续同服务端进行输入输出交互，同时也可以打印堆栈信息进行确认，此时依旧阻塞在read方法而不是accept方法，此处不再截图。如果此时关闭客户端Socket（即控制台），那么此次Socket通信将结束，然后重新阻塞在Accept继续监听端口，等待新的客户端连接的到来。
因此可以确认ServerSocket两个阻塞点，分别是accept、read，accept阻塞等待新的socket通信建立请求，read阻塞等待客户端输入。
四、手写客户端
public class BioClient {
public static void main(String[] args) {
Socket clientSocket = null;
OutputStream outputStream = null;
InputStream inputStream = null;
try{
// 新建一个Socket请求
clientSocket = new Socket("localhost",8080);
System.out.println("Build the connection successfully!"+" ,"+new Date().toString());
outputStream = clientSocket.getOutputStream();
inputStream = clientSocket.getInputStream();
byte[] buffer = new byte[1024];
Scanner scanner = new Scanner(System.in);
while(true){
System.out.println("Please input a String !"+" ,"+new Date().toString());
String string = scanner.nextLine();
if("end".equals(string)){
System.out.println("Client end"+" ,"+new Date().toString());
break;
}
outputStream.write(("This is a new request: "+string).getBytes());
int length = 0;
if ((length = inputStream.read(buffer)) > 0) {//阻塞
}
System.out.println("The response is:" + new String(buffer, 0, length)+" ,"+new Date().toString());
}
}catch (Exception e){
} finally {
if (clientSocket != null) {
try {
clientSocket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (inputStream != null) {
try {
inputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (outputStream != null) {
try {
outputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
启动main方法，如下截图（客户端和服务端）：
客户端可以一直接受请求，直到输入end结束此次客户端输入，那么服务端能一直接受请求，然后给出答复，当客户端断开请求后，服务端重新恢复监听，等待新的socket请求的到来。
因此，在BIO通信模型中，Socket通信的发起以及结束都是客户端进行的。
五、多Socket客户端请求处理
上面进行的是1对1的Socket通信建立，如果已经有一个Socket请求在处理的时候，此时再来一个socket请求，那么会怎样呢，我们通过两个控制台简历请求进行测试。
如截图所示，客户端1和客户端建立Socket请求的通信并未报错，客户端①可以正常通信，但是客户端②的请求并未得到响应。
我们因此可以知道BIO是一对一应答模型，一个Socekt只能支持一个通信，如果一个客户端没有断开，当前线程会阻塞在读操作。要想实现同时处理多个通信，那么就必须建立多个Socket，因此此时服务端可以通过多线程，在socket请求到来时，单独为通信建立一个Socket进行通信，代码如下：
public class BioServerThread {
public static void main(String[] args) {
int port=8080;
ServerSocket serverSocket=null;
try{
serverSocket=new ServerSocket(port);
Socket socket=null;
while (true){
socket=serverSocket.accept();//拿到socket
//连接量大的时候 会拖垮cpu
new Thread(new SocketHandler(socket)).start();
}
}catch (Exception e){
e.printStackTrace();
}finally {
if (serverSocket!=null){
try {
serverSocket.close();
serverSocket=null;
}catch (IOException e){
e.printStackTrace();
}
}
}
}
}
public class SocketHandler implements Runnable {
private Socket socket;
public SocketHandler(Socket socket) {
this.socket=socket;
}
public void run() {
InputStream in = null;
OutputStream out = null;
try {
in = socket.getInputStream();
byte[] buffer = new byte[1024];
int length = 0;
while ((length = in.read(buffer)) > 0) {//阻塞
System.out.println("input is:" + new String(buffer, 0, length));
out = socket.getOutputStream();
out.write("success".getBytes());
System.out.println("end");
}
} catch (Exception e) {
e.printStackTrace();
} finally {
if (in != null) {
try {
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (out != null) {
try {
out.close();
}catch (Exception e){
e.printStackTrace();
}
}
if (socket!=null){
try {
socket.close();
}catch (Exception e){
e.printStackTrace();
}
}
}
}
}
此时用两个控制台建立两个socket请求进行测试：
如图所示，客户端①和客户端②同时得到了服务端的返回，服务端成功完成了多请求的处理。
六、线程池管理Socket
虽然为了解决该问题可以引入多线程，实现伪异步IO，但是因为处理线程和客户端是1:1的关系，随着客户端请求增大，线程数随着上升，会极大的消耗cpu资源，引起服务器异常。为了保障服务器资源可以实现线程池，如果发生读取数据较慢时，大量并发的情况下，其他接入的客户都只能一直等待。
代码如下：
public class ServerHandlerExcutePool {
private ExecutorService executor;
public ServerHandlerExcutePool(int maxPoolSize, int queueSize){
executor=new ThreadPoolExecutor(2, maxPoolSize, 120L, TimeUnit.SECONDS,new ArrayBlockingQueue<Runnable>(queueSize));
}
public void execute(Runnable task){
executor.execute(task);
}
}
public class BioServerThreadPool {
public static void main(String[] args) {
int port=8080;
ServerSocket serverSocket=null;
try{
//1000000
serverSocket=new ServerSocket(port);
Socket socket=null;
//100000 100000
ServerHandlerExcutePool excutePool=new ServerHandlerExcutePool(2,100);
while (true){
socket=serverSocket.accept();
excutePool.execute(new SocketHandler(socket));
}
}catch (Exception e){
e.printStackTrace();
}finally {
if (serverSocket!=null){
try {
serverSocket.close();
serverSocket=null;
}catch (IOException e){
e.printStackTrace();
}
}
}
}
}
如截图所示，我设置线程池最多处理两个请求，那么此时第三个客户端的连接依旧无法处理，这样避免了创建大量的线程创建新的Socket，多余线程池大容量的请求只能阻塞。
综上所述，BIO的特点是缺乏弹性伸缩能力，在高并发这种大量请求来临时，并不具备强大的处理能力。
原文地址：https://www.cnblogs.com/jing99/p/11993041.html