I/O之BIO详解

简介

传统的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一个socket
        Socket 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 {

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