Java NIO（二）BIO

系列文章目录

第一篇 Java NIO（一）I/O简介
第一篇 Java NIO（二）BIO
第一篇 Java NIO（三）NIO之Buffer
第一篇 Java NIO（四）NIO之Channel
第一篇 Java NIO（五）NIO之Selector
第一篇 Java NIO（六）Netty

---

Java NIO（二）BIO

---

前言

Java的IO体系发展历程中，经历了从BIO演进到NIO的过程，本篇文章主要是对BIO进行一些学习总结。
之前的I/O简介中我们讲述了底层操作系统的五种IO模型。Java中的BIO就是基于第一种I/O模型——阻塞式I/O。
BIO的操作是基于流来进行操作的，下面我们主要看下BIO模式下的网络IO

---

一、流

首先简单介绍下流的概念，在I/O中，用流的抽象概念来表示数据序列，即：流代表一系列的数据序列。输入流代表从数据源读取数据序列，输出流代表向数据源写入数据序列。
在Java中，InputStream代表输入流，OutputStream代表输出流，它们的一系列继承关系丰富了整个BIO的流体系。本篇文章不做重点介绍，有兴趣的同学可以在JDK的源码中自己跟进了解。

二、网络I/O

1.BIO的通信模模式

如上图所示，因为BIO底层是采用的阻塞式I/O模型，因此每当有一个客户端连接到服务器后，都需要开启一个线程去处理，并且该线程负责该客户端本次请求的整个过程，包括接入，读取，写入等各个阶段。

2.使用方式

客户端代码：

public class BIOClient {

    public void start(String host, int port) {
        try {
        	// 开启10个client连接
            for (int i = 0; i < 10; i++) {
                Socket client = new Socket(host, port);
                OutputStream os = client.getOutputStream();
                String name = UUID.randomUUID().toString();
                String msg = "hello server" + i;
                System.out.println("client " + name + "say: " + msg);
                os.write(msg.getBytes());
                os.close();
                client.close();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        new BIOClient().start("localhost", 8089);
    }
}

1）单线程模型

代码如下：

服务端代码：

public class HttpServer01 {

    public static void main(String[] args) throws Exception {
        ServerSocket serverSocket = new ServerSocket(8801);
        while (true) {
            try {
               // 线程阻塞在accept方法上，直到有客户端接入
                Socket socket = serverSocket.accept();
                service(socket);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

    }


    private static void service(Socket socket) {
        try {
            PrintWriter printWriter = new PrintWriter(socket.getOutputStream(), true);
            printWriter.println("HTTP/1.1 200 OK");
            printWriter.println("Content-Type:text/html;charset=utf-8");
            String body = "hello,bio1";
            printWriter.println("Content-Length:" + body.getBytes().length);
            printWriter.println();
            printWriter.write(body);
            printWriter.close();
            socket.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

单线程模式的情景下，每个client请求到达服务器时，只能等待上一个client请求在服务器中处理完成后，服务器才能处理下一个client请求。于是便需要多线程去支持并发请求。

2）多线程版本1

服务端代码：

public class HttpServer02 {

    public static void main(String[] args) throws Exception {
        ServerSocket serverSocket = new ServerSocket(8802);
        while (true) {
            try {
                Socket socket = serverSocket.accept();
                // 每次请求进来后都开启一个新的线程去处理
                new Thread(() -> {
                    service(socket);
                }).start();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    private static void service(Socket socket) {
        try {
            PrintWriter printWriter = new PrintWriter(socket.getOutputStream(), true);
            printWriter.println("HTTP/1.1 200 OK");
            printWriter.println("Content-Type:text/html;charset=utf-8");
            String body = "hello,bio2";
            printWriter.println("Content-Length:" + body.getBytes().length);
            printWriter.println();
            printWriter.write(body);
            printWriter.close();
            socket.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

多线程模式下，每次有新的client请求进来后，服务器都会开启一个新的线程去处理。但是我们都知道，在操作系统中线程时一个很昂贵的资源，上述代码示例中有个问题是，当请求量非常大的时候，线程资源开辟过多可能会导致系统的崩溃。于是，想到使用线程池去统一管理工作线程。

3）多线程版本2

服务端代码：

public class HttpServer03 {

    public static void main(String[] args) throws IOException {
        ExecutorService executorService = Executors.newFixedThreadPool(
                Runtime.getRuntime().availableProcessors() + 2);
        final ServerSocket serverSocket = new ServerSocket(8803);
        while (true) {
            try {
                final Socket socket = serverSocket.accept();
                // 向线程池提交任务
                executorService.execute(() -> service(socket));
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    private static void service(Socket socket) {
        try {
            PrintWriter printWriter = new PrintWriter(socket.getOutputStream(), true);
            printWriter.println("HTTP/1.1 200 OK");
            printWriter.println("Content-Type:text/html;charset=utf-8");
            String body = "hello,nio1";
            printWriter.println("Content-Length:" + body.getBytes().length);
            printWriter.println();
            printWriter.write(body);
            printWriter.close();
            socket.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

优化后的线程池版本可以很有效的控制客户端的接入，上述代码比较粗糙，感兴趣的读者还可以通过线程池的提交策略、队列等手段继续优化。此时，由于线程池的数量一定，当线程池中的工作线程满了之后，再有新的请求进来，就会被阻塞或者是拒绝（取决于线程池的策略和队列的设计）。

---

总结

从上述的代码和结果可以看到，因为对于每个请求来说，都需要一个线程去专门处理，而在操作系统中，线程资源又是极其昂贵的存在，因此，BIO模式对于请求的处理能力是有限的，即对于并发的处理能力是有限的。所以在后来Java IO体系的发展中，出现了新的IO体系NIO。该部分内容，我们将会在后续文章进行学习总结