Java中的流与IO

• J3 - 白起
• 技术（I/O流）

最近在看 Netty 相关的内容，以后就会写一些和 Netty 相关技术的文章。

而 Netty 作为业界最流行的 NIO 框架之一，在开始之前就自然要全面的介绍一下 BIO、NIO 以及 AIO 相关的内容了。

所以在开始 Netty 之前，我就来介绍介绍 I/O 的基本体系，以此来向你们构建出 Netty 的魅力。

一、流是什么

百度概念：

流是一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。即数据在两设备间的传输称为流。流的本质是数据传输，根据数据传输特性将流抽象为各种类，方便更直观的进行数据操作。

总结就是：流就是传输，传输的内容就是字节

在 Java 中我们常说的字节流、字符流其实本质就是对流传输内容的不同而划分的两种操作。字节流操作单位是字节，字符流操作单位是一个个字符。

前面说过，流是有起点和终点的。而又因为起点和终点的各不相同，流又可分为：输入流、输出流。

理解：

内存 -> 硬盘 = 输出流（OutputStream、Writer）

硬盘 -> 内存 = 输入流（InputStream、Reader）

对于流的操作 Java 提供了非常多的 API 操作，包位置：java.io、java.nio。

因为本篇不是教大家如何使用 API 的，所以其中的使用方法就不过多的介绍了，但我岂是那种不负责任的男人😀，已经帮你们找好要复习 IO 流操作的基础教程了👉👉👉点这里。

但为了引出 BIO、NIO及 AIO 相关概念，小小案例还是要写一下的，如下：

@Slf4j
public class BioTest {

    /**
     * 流的形式操作文件
     */
    @Test
    public void streamTest() throws Exception {

        // 定义两个文件，in.txt 和 out.txt（提前在src目录下创建好两个文件）
        File inFile = new File("src/in.txt");
        File outFile = new File("src/out.txt");

        // 定义一个对 in.txt 操作的流对象
        InputStream inputStream = new FileInputStream(inFile);
        // 开始读取文件
        byte[] bytes = new byte[8];
        inputStream.read(bytes);
        System.out.println(new String(bytes));

        // 定义 out.txt 操作的流对象
        OutputStream outputStream = new FileOutputStream(outFile);
        // 开始写出文件
        outputStream.write(bytes);
        outputStream.write("\nout-write".getBytes(StandardCharsets.UTF_8));

    }

    /**
     * 阻塞形式操作网络编程
     */
    @Test
    public void blockTest() throws Exception {
        /*
        1、运行服务端发现，服务端在获取客户端连接及获取客户端数据时，都会堵塞
        */
    }

    @Test
    public void server() throws Exception {
        // 创建服务端对象
        ServerSocket serverSocket = new ServerSocket(9528);
        log.info("创建了一个服务端对象,{}", serverSocket);
        // 获取客户端链接的 soclet 对象
        Socket accept = serverSocket.accept();
        log.info("获取到了客户端连接对象,{}", accept);
        InputStream inputStream = accept.getInputStream();
        byte[] bytes = new byte[100];
        inputStream.read(bytes);
        log.info("客户端发来的内容：{}", new String(bytes));
    }

    @Test
    public void client() throws Exception {
        // 创建客户端，指定服务端ip及端口，进行连接
        Socket client = new Socket("localhost", 9528);
        log.info("客户端创建完毕,{}", client);
        // 开始向务端发送消息
        OutputStream outputStream = client.getOutputStream();
        outputStream.write("hello world!".getBytes(StandardCharsets.UTF_8));
    }
}

上面案例展示了两种效果，一流操作、二阻塞操作。

而对于流和阻塞正是 Java 传统 IO（BIO） 的一种拙劣表现，流在数据的运输上效率比不上带有通道的缓冲区；而阻塞更比不上非阻塞的 Selector 操作。

二、BIO

同步阻塞I/O模式，数据的读取写入必须阻塞在一个线程内等待其完成。

而且也是 Java 1.4 之前唯一的 IO 模式。

上面出现了两个名词：同步，阻塞，那么下面我先解释一下。

名词	解释	例子
同步	指的是用户进程触发IO操作并等待或者轮询的去查看IO操作是否就绪	苦逼程单身程序员A，为了能找到相亲对象天天上班下班搜罗各大单身小姐姐联系方式，这种亲自出马忽略工作的就是同步。
异步	异步是指用户进程触发IO操作以后便开始做自己的事情，而当IO操作已经完成的时候会得到IO完成的通知（异步的特点就是通知）	聪明灵活单身程序员B，为了能找到各种相亲小姐姐的联系方式，直接联系了某大型婚介公司，交由婚介公司获取小姐姐联系方式，这种委托形式而不耽误正常工作的就是异步。
阻塞	所谓阻塞方式的意思是指, 当试图对该文件描述符进行读写时, 如果当时没有东西可读,或者暂时不可写, 程序就进入等待 状态, 直到有东西可读或者可写为止	程序员A，好不容易找到几个身材条件都不错的小姐姐，但是就是一直约不上人家，只能等人家空闲时间，这种等待就是阻塞。
非阻塞	非阻塞状态下, 如果没有东西可读, 或者不可写, 读写函数马上返回, 而不会等待	程序员B，因为是大型婚介公司，找得到联系方式，肯定也是约会相亲一条龙服务，所以就顺利的和小姐姐见面谈人生谈理想谈…，这种直接约的就是非阻塞。

通过上面我写的代码案例和这张表格，相信大家对与同步及阻塞有了很清晰的认识了。下面我们一起看看 BIO 的模型图：

从图中可以看出，一个服务器会对应这多个客户端，每个客户端都对着不同的线程，这就导致了单线程环境下客户端 A 与服务端通信时，B、C 都需要进行等待阻塞，只有 A 通信完毕 B、C 客户端才能进行后续步骤。

案例代码，见第一小节。

三、NIO

同步非阻塞I/O模式，Java 1.4 之后开始支持，并提供了像 Channel , Selector，Buffer等抽象（后面会重点介绍这三大组件）。

我们都知道传统 BIO 是面向流的，而 NIO 意识到流的效率问题就提出了面向缓冲（块）的方式进行 IO 操作大大提升了传输效率。

而且 NIO 提供了与传统 BIO 模型中的 Socket 和 ServerSocket 相对应的 SocketChannel 和 ServerSocketChannel 两种不同的套接字通道实现,两种通道都支持阻塞和非阻塞两种模式。阻塞模式使用就像传统中的支持一样，比较简单，但是性能和可靠性都不好；非阻塞模式正好与之相反。对于低负载、低并发的应用程序，可以使用同步阻塞I/O来提升开发速率和更好的维护性；对于高负载、高并发的（网络）应用，应使用 NIO的非阻塞模式来开发。

NIO模型图如下：

案例：

@Slf4j
public class NioTest {

    @Test
    public void serverTest() throws Exception{
        //创建serverSocketChannel
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        //绑定端口
        serverSocketChannel.socket().bind(new InetSocketAddress(6666));
        //设置为非阻塞
        serverSocketChannel.configureBlocking(false);
        //得到Selector对象
        try (Selector selector = Selector.open()) {
            //把ServerSocketChannel注册到selector，事件为OP_ACCEPT
            serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
            //如果返回的>0，表示已经获取到关注的事件
            while (selector.select() > 0) {
                Set<SelectionKey> selectionKeys = selector.selectedKeys();
                Iterator<SelectionKey> iterator = selectionKeys.iterator();
                while (iterator.hasNext()) {
                    //获得到一个事件
                    SelectionKey next = iterator.next();
                    //如果是OP_ACCEPT，表示有新的客户端连接
                    if (next.isAcceptable()) {
                        //给该客户端生成一个SocketChannel
                        SocketChannel accept = serverSocketChannel.accept();
                        accept.configureBlocking(false);
                        //将当前的socketChannel注册到selector，关注事件为读事件，同时给socket Channel关联一个buffer
                        accept.register(selector, SelectionKey.OP_READ, ByteBuffer.allocate(1024));
                        log.info("获取到一个客户端连接");
                        //如果是读事件
                    } else if (next.isReadable()) {
                        //通过key 反向获取到对应的channel
                        SocketChannel channel = (SocketChannel) next.channel();
                        //获取到该channel关联的buffer
                        ByteBuffer buffer = (ByteBuffer) next.attachment();
                        while (channel.read(buffer) != -1) {
                            buffer.flip();
                            log.info(new String(buffer.array(), 0, buffer.limit()));
                            buffer.clear();
                        }
                    }
                    // 这个很重要，在处理完事件之后，要移除该事件
                    iterator.remove();
                }
            }
        }

    }

    @Test
    public void clientTest() throws Exception{
        //得到一个网络通道
        SocketChannel socketChannel = SocketChannel.open();
        //设置为非阻塞
        socketChannel.configureBlocking(false);
        //提供服务器端的IP和端口
        InetSocketAddress inetSocketAddress = new InetSocketAddress("localhost", 9528);
        //连接服务器
        if (!socketChannel.connect(inetSocketAddress)) {
            while (!socketChannel.finishConnect()) {
                log.info("连接需要时间,客户端不会阻塞...你可以去干别的事情了");
            }
        }
        //连接成功,发送数据
        String str = "J3-白起";
        ByteBuffer byteBuffer = ByteBuffer.wrap(str.getBytes());
        socketChannel.write(byteBuffer);
        socketChannel.close();
        log.info("客户端退出");
    }

}

这段代码，可以体现服务端获取客户端连接时时不需要阻塞的，并且在读取客户端发来的数据时也是不需要阻塞有数据就读没有就往下执行，这也是 Netty 框架流行原因之一。

四、AIO

异步非阻塞I/O模式，在 Java 7 中引入了 NIO 的改进版 NIO 2。

异步 IO 是基于事件和回调机制实现的，也就是应用操作之后会直接返回，不会堵塞在那里，当后台处理完成，操作系统会通知相应的线程进行后续的操作。

对于 AIO 在网上资料还不是很多，并且应用还不是很广泛，所以就…

五、最后

本篇主要是让大家对 Java IO 的模型体系有个大致了解，知道有 BIO、NIO、AIO 这一回事和了解同步、阻塞的区别就行。

对于具体的应用，我是没有具体展开说的，因为 BIO 是基础我已经贴过教程地址了☝☝☝。而 NIO 是学 Netty 的前提我后面会对这部分持续的输出，至于 AIO 应用还不是非常广泛我也不会，所以可以先不用关注了解就行。

好了，介绍了这篇，那下篇就是 NIO 讲解了，关注我，咱们下期见。

查阅或扩展资料：

• 《Netty权威指南第二版》

• 《漫话：如何给女朋友解释什么是Linux的五种IO模型？》

• https://www.zhihu.com/question/64056856/answer/1004584371

• https://segmentfault.com/a/1190000037714804

---

• 由于博主才疏学浅，难免会有纰漏，假如你发现了错误或偏见的地方，还望留言给我指出来，我会对其加以修正。

• 如果你觉得文章还不错，你的转发、分享、点赞、留言就是对我最大的鼓励。

• 感谢您的阅读，十分欢迎并感谢您的关注。

^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

优快云：J3 - 白起

掘金：J3-白起

知乎：J3-白起

这是一个技术一般，但热衷于分享；经验尚浅，但脸皮够厚；明明年轻有颜值，但非要靠才华吃饭的程序员。

^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^