简介

传统的BIO编程网络编程的基本模型是C/S模型,即两个进程间的通信。
服务端提供IP和监听端口,客户端通过连接操作想服务端监听的地址发起连接请求,通过三次握手连接,如果连接成功建立,双方就可以通过套接字进行通信。
传统的同步阻塞模型开发中,ServerSocket负责绑定IP地址,启动监听端口;Socket负责发起连接操作。连接成功后,双方通过输入和输出流进行同步阻塞式通信。

到底什么是“IO Block”

很多人说BIO不好，会“block”，但到底什么是IO的Block呢？考虑下面两种情况：

1、用系统调用read从socket里读取一段数据
2、用系统调用read从一个磁盘文件读取一段数据到内存

如果你的直觉告诉你，这两种都算“Block”，那么很遗憾，你的理解与Linux不同。Linux认为：

对于第一种情况，算作block，因为Linux无法知道网络上对方是否会发数据。如果没数据发过来，对于调用read的程序来说，就只能“等”。
对于第二种情况，不算做block。

是的，对于磁盘文件IO，Linux总是不视作Block。
你可能会说，这不科学啊，磁盘读写偶尔也会因为硬件而卡壳啊，怎么能不算Block呢？但实际就是不算。

一个解释是，所谓“Block”是指操作系统可以预见这个Block会发生才会主动Block。
例如当读取TCP连接的数据时，如果发现Socket buffer里没有数据就可以确定定对方还没有发过来，于是Block；
而对于普通磁盘文件的读写，也许磁盘运作期间会抖动，会短暂暂停，但是操作系统无法预见这种情况，只能视作不会Block，照样执行。

BIO

BIO是Blocking IO的意思。在类似于网络中进行read, write, connect一类的系统调用时会被卡住。
举个例子，当用read去读取网络的数据时，是无法预知对方是否已经发送数据的。因此在收到数据之前，能做的只有等待，直到对方把数据发过来，或者等到网络超时。
对于单线程的网络服务，这样做就会有卡死的问题。因为当等待时，整个线程会被挂起，无法执行，也无法做其他的工作。
于是，网络服务为了同时响应多个并发的网络请求，必须实现为多线程的。每个线程处理一个网络请求。线程数随着并发连接数线性增长。这的确能奏效。实际上2000年之前很多网络服务器就是这么实现的。但这带来两个问题：
1、线程越多，上下文切换就越多，而上下文切换时一个比较重的操作，会无所浪费大量的CPU。
2、每个线程会占用一定的内存作为线程的栈。比如有1000个线程同时运行，每个占用1MB内存，就会占用了1个G的内存。
问题的关键在于，当调用read接受网络请求时，有数据到了就用，没数据到时，实际上是可以干别的。使用大量线程，仅仅是因为Block发生，没有其他办法。
当然你可能会说，是不是可以弄个线程池呢？这样既能并发的处理请求，又不会产生大量线程。但这样会限制最大并发的连接数。比如你弄4个线程，那么最大4个线程都Block了就没法响应更多请求了。

BIO通讯模型

如图，每一个客户端经过向Acceptor请求连接，服务端都需要为之创建一个新的线程服务，且该线程在期间无法做任何事情。

当然，你也可以利用线程池实现成上图这样的伪异步IO，这时服务端能同时处理的请求就是线程池中的最大线程数。

BIO实现Echo网络通信

代码会附上详细的注释，可以复制到对应的编程软件中帮助理解。

客户端代码

import java.io.IOException;
import java.io.PrintStream;
import java.net.Socket;
import java.util.Scanner;public class BioClient {public static void main(String[] args) throws IOException, InterruptedException {// new一个socketSocket socket = new Socket("localhost", 8080);//处理输出流Scanner scanner = new Scanner(socket.getInputStream());//设置分隔符scanner.useDelimiter("\n");//处理输出流PrintStream out = new PrintStream(socket.getOutputStream());//循环标志boolean flag = true;Scanner sc = new Scanner(System.in);while (flag) {//从键盘输入System.out.println("请输入");String inputDate = sc.next().trim();//把数据发送到服务器上out.println(inputDate);//此处需要阻塞，如果服务端没有响应的数据传输过来，if (scanner.hasNext()) {String str = scanner.next();System.out.println(str);}if ("byebye".equals(inputDate)) {flag = false;}}sc.close();scanner.close();out.close();socket.close();}
}

服务端代码

import java.io.IOException;
import java.io.PrintStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;public class BioServer {private static int DEFAULT_PORT = 9999;private static ServerSocket serverSocket;private static boolean flag = true;/*** 固定两百个线程连接数*/private static ExecutorService executorService = Executors.newFixedThreadPool(200);private static class ServerHandler implements Runnable {private Socket socket;private Scanner scanner;private PrintStream out;private boolean flag;public ServerHandler(Socket socket) {this.socket = socket;try {this.flag = true;this.scanner = new Scanner(this.socket.getInputStream());this.scanner.useDelimiter("\n");this.out = new PrintStream(this.socket.getOutputStream());} catch (IOException E) {}}public void run() {while(flag) {//此处需要阻塞 也就是这个线程一直在等待客户端的输入if(scanner.hasNext()) {String value = scanner.next().trim();if("byebye".equals(value)) {out.println("client : byebye !");flag = false;} else {out.println("client:" + value);}}}this.scanner.close();this.out.close();try {this.socket.close();} catch (IOException e) {e.printStackTrace();}System.out.println("断开连接成功.");}}public static void main(String[] args) throws IOException {//开启serverSocketserverSocket = new ServerSocket(9999);System.out.println("服务器启动 端口号:9999");while (flag) {// 此处需要阻塞知道有客户端连接成功Socket socket = serverSocket.accept();System.out.println("有连接进来了.");// 将对应的socket交给线程池处理executorService.submit(new ServerHandler(socket));}executorService.shutdown();serverSocket.close();}
}

总结

使用BIO，缺点在上述已经总结出来了。
每个客户端连接需要一个同步并阻塞的线程为之服务。
当然也有优点。
当服务端请求量不大时，每个线程都专注于处理自己对应的客户，相率会相对来说比较高。