五、05【Java IO模型】之BIO NIO AIO介绍

最新推荐文章于 2022-08-18 13:13:53 发布
最新推荐文章于 2022-08-18 13:13:53 发布
阅读量136 收藏
点赞数
分类专栏： Java基础 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46129103/article/details/126092348
版权

IO模型

IO模型就是说用什么样的通道进行数据的发送和接收。

在《Unix网络编程》一书中提到了五种IO模型，分别是：阻塞IO、非阻塞IO、多路复用IO、信号驱动IO以及异步IO

Java支持3种网络编程IO模式：BIO（阻塞IO），NIO（非阻塞IO），AIO（异步非阻塞IO）

BIO（Blocking IO）

同步阻塞IO，就是一个客户端连接对应一个处理线程。

在最开始学Java的时候，IO流那些都是属于BIO模型的。

缺点

1）IO代码里read操作是阻塞操作，如果连接不做数据读写操作会导致线程阻塞，浪费资源。

2）如果线程很多，会导致服务器线程太多，压力太大。

应用场景

BIO方式适用于连接数比较小且固定的架构，这种方式对服务器资源要求比较高，但程序简单易理解。

代码示例

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * Socket 流套接字 服务端
 * ...
 */
public class SocketServer {

    public static void main(String[] args) throws IOException {
        // 创建服务器套接字并绑定到指定的端口。
        ServerSocket serverSocket = new ServerSocket(9999);

        // 死循环，保证服务端一直运行在线
        while (true) {
            System.out.println("服务端等待连接：" + System.currentTimeMillis());
            // 监听要建立到此套接字的连接并接受。该方法将一直阻塞，直到建立连接。
            final Socket socket = serverSocket.accept();
            System.out.println("监听到客户端，建立连接");
            new Thread(new Runnable() {
                public void run() {
                    try {
                        handler(socket);
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }
    }

    private static void handler(Socket socket) throws IOException {
        System.out.println("Thread ID = " + Thread.currentThread().getId());
        byte[] bytes = new byte[1024];
        System.out.println("准备read");
        // 接收客户端的数据，也是阻塞方法，没有数据可读时就阻塞
        int read = socket.getInputStream().read(bytes);
        System.out.println("read完毕");
        if (read != -1) {
            System.out.println("接收到客户端的数据：" + new String(bytes, 0, read));
            System.out.println("Thread ID = " + Thread.currentThread().getId());
        }
        // 向客户端响应写出数据
        socket.getOutputStream().write("HelloClient".getBytes());
        socket.getOutputStream().flush();
    }
}
import java.io.IOException;
import java.net.Socket;

/**
 * Socket 流套接字 客户端
 * ...
 */
public class SocketClient {

    public static void main(String[] args) throws IOException {
        // 创建一个流套接字并将其连接到指定的主机端口
        Socket socket = new Socket("localhost", 9999);

        // 向服务端发送数据
        socket.getOutputStream().write("HelloServer".getBytes());
        socket.getOutputStream().flush();
        System.out.println("客户端向服务端发送数据结束！");
        byte[] bytes = new byte[1024];

        // 接收服务端响应数据
        socket.getInputStream().read(bytes);
        System.out.println("接收到服务端的数据：" + new String(bytes));

        // 关闭流套接字
        socket.close();
    }
}

BIO模型

 NIO（Non Blocking IO）

同步非阻塞IO，服务器实现模式为一个线程可以处理多个请求(连接)，客户端发送的连接请求都会注册到多路复用器selector上，多路复用器轮询到连接有IO请求就进行处理。I/O多路复用底层一般用的Linux API（select，poll，epoll）来实现，他们的区别如下表：

 应用场景

NIO方式适用于连接数目多且连接比较短（轻操作） 的架构， 比如聊天服务器， 弹幕系统， 服务器间通讯，编程比较复杂， JDK1.4 开始支持；

NIO模型

 NIO三大核心组件：Buffer(缓冲区)、 Channel(通道)、Selector(选择器)

1）channel 类似于流，每个 channel 对应一个 buffer缓冲区，buffer 底层是个数组.

2）channel 会注册到 selector 上，由 selector 根据 channel 读写事件的发生将其交由某个空闲的线程处理.

3）selector 可以对应一个或多个线程.

4）NIO 的 Buffer 和 channel 都是既可以读也可以写.

代码示例

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;

/**
 * NIO 服务端
 * ...
 */
public class NioServer {

    public static void main(String[] args) throws IOException {
        // 创建一个在本地端口进行监听的服务Socket通道
        ServerSocketChannel ssc = ServerSocketChannel.open();
        // 设置非阻塞模式。否则会报错，selector模式本身就是非阻塞模式
        ssc.configureBlocking(false);
        // 绑定端口
        ssc.socket().bind(new InetSocketAddress(9999));
        // 创建一个选择器
        Selector selector = Selector.open();
        // 把ServerSocketChannel注册到selector上，并且selector对客户端accept连接操作感兴趣
        ssc.register(selector, SelectionKey.OP_ACCEPT);
        // 无限循环保证服务端在线运行
        while (true) {
            System.out.println("服务端等待事件发生");
            // 轮询监听channel里的key，select是阻塞的，accept()也是阻塞的
            int select = selector.select();
            System.out.println("有事件发生了="+select);
            // 有客户端请求，被轮询监听到
            Iterator<SelectionKey> it = selector.selectedKeys().iterator();
            while (it.hasNext()) {
                SelectionKey key = it.next();
                // 删除当前已处理的key，防止下次select重复处理
                it.remove();
                // 处理监听到key
                handle(key);
            }
        }
    }

    private static void handle(SelectionKey key) throws IOException {
        if (key.isAcceptable()) {
            System.out.println("连接事件");
            ServerSocketChannel ssc = (ServerSocketChannel) key.channel();
            // NIO非阻塞体现：此处accept方法是阻塞的，但是这里因为是发生了连接事件，所以这个方法会马上执行完，不会阻塞
            // 处理完连接请求不会继续等待客户端的数据发送
            SocketChannel sc = ssc.accept();
            sc.configureBlocking(false);
            // 通过Selector监听Channel时对读事件感兴趣
            sc.register(key.selector(), SelectionKey.OP_READ);
        } else if (key.isReadable()) {
            System.out.println("数据可读事件");
            SocketChannel sc = (SocketChannel) key.channel();
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            // NIO非阻塞体现:首先read方法不会阻塞，其次这种事件响应模型，当调用到read方法时肯定是发生了客户端发送数据的事件
            int len = sc.read(buffer);
            if (len != -1) {
                System.out.println("读取到客户端发送的数据：" + new String(buffer.array(), 0, len));
            }
            ByteBuffer bufferToWrite = ByteBuffer.wrap("HelloClient".getBytes());
            sc.write(bufferToWrite);
            key.interestOps(SelectionKey.OP_READ | SelectionKey.OP_WRITE);
        } else if (key.isWritable()) {
            SocketChannel sc = (SocketChannel) key.channel();
            System.out.println("write事件");
            // NIO事件触发是水平触发
            // 使用Java的NIO编程的时候，在没有数据可以往外写的时候要取消写事件，
            // 在有数据往外写的时候再注册写事件
            key.interestOps(SelectionKey.OP_READ);
            // sc.close();
        }
    }
}

NIO服务端程序步骤

1）创建一个 ServerSocketChannel 和 Selector ，并将 ServerSocketChannel 注册到 Selector

2）selector 通过 select() 方法监听 channel 事件，当客户端连接时，selector 监听到连接事件， 获取到 ServerSocketChannel 注册时绑定的 selectionKey

3）selectionKey 通过 channel() 方法可以获取绑定的 ServerSocketChannel

4）ServerSocketChannel 通过 accept() 方法得到 SocketChannel

5）将 SocketChannel 注册到 Selector 上，关注 read 事件

6）注册后返回一个 SelectionKey，和该 SocketChannel 关联

7）selector 继续通过 select() 方法监听事件，当客户端发送数据给服务端，selector 监听到read事件，获取到 SocketChannel 注册时绑定的 selectionKey

8）selectionKey 通过 channel() 方法可以获取绑定的 socketChannel

9）将 socketChannel 里的数据读取出来

10）用 socketChannel 将服务端数据写回客户端

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.util.Iterator;

/**
 * NIO 客户端
 * ...
 */
public class NioClient {

    // 通道管理器
    private Selector selector;

    /**
     * 启动客户端测试
     *
     * @throws IOException
     */
    public static void main(String[] args) throws IOException {
        NioClient client = new NioClient();
        client.initClient("127.0.0.1", 9999);
        client.connect();
    }

    /**
     * 获得一个Socket通道，并对该通道做一些初始化的工作
     *
     * @param ip   连接的服务器的ip
     * @param port 连接的服务器的端口号
     * @throws IOException
     */
    public void initClient(String ip, int port) throws IOException {
        // 获得一个Socket通道
        SocketChannel channel = SocketChannel.open();
        // 设置通道为非阻塞
        channel.configureBlocking(false);
        // 获得一个通道管理器
        this.selector = Selector.open();
        // 客户端连接服务器,其实方法执行并没有实现连接，需要在listen()方法中调用 channel.finishConnect(); 才能完成连接
        channel.connect(new InetSocketAddress(ip, port));
        // 将通道管理器和该通道绑定，并为该通道注册OP_CONNECT事件
        channel.register(selector, SelectionKey.OP_CONNECT);
    }

    /**
     * 采用轮询的方式监听selector上是否有需要处理的事件，如果有，则进行处理
     *
     * @throws IOException
     */
    private void connect() throws IOException {
        // 轮询访问selector
        while (true) {
            // 选择一组可以进行I/O操作的事件，放在selector中,客户端的该方法不会阻塞，
            // 这里和服务端的方法不一样，查看api注释可以知道，当至少一个通道被选中时，
            // selector的wakeup方法被调用，方法返回，而对于客户端来说，通道一直是被选中的
            selector.select();
            // 获得selector中选中的项的迭代器
            Iterator<SelectionKey> it = this.selector.selectedKeys().iterator();
            while (it.hasNext()) {
                SelectionKey key = it.next();
                // 删除已选的key,以防重复处理
                it.remove();
                // 连接事件发生
                if (key.isConnectable()) {
                    SocketChannel channel = (SocketChannel) key.channel();
                    // 如果正在连接，则完成连接
                    if (channel.isConnectionPending()) {
                        channel.finishConnect();
                    }
                    // 设置成非阻塞
                    channel.configureBlocking(false);
                    // 给服务端发送消息
                    ByteBuffer buffer = ByteBuffer.wrap("HelloServer".getBytes());
                    channel.write(buffer);
                    // 在和服务端连接成功之后，为了可以接收到服务端的信息，需要给通道设置读权限。为该通道注册OP_READ事件
                    channel.register(this.selector, SelectionKey.OP_READ);
                } else if (key.isReadable()) {
                    // 得到事件发生的Socket通道
                    SocketChannel channel = (SocketChannel) key.channel();
                    // 创建读取的缓冲区
                    ByteBuffer buffer = ByteBuffer.allocate(512);
                    int len = channel.read(buffer);
                    if (len != -1) {
                        System.out.println("客户端收到信息：" + new String(buffer.array(), 0, len));
                    }
                }
            }
        }
    }
}

总结

NIO模型的 selector 就像一个大总管，负责监听各种IO事件，然后转交给后端线程去处理；

NIO相对于BIO非阻塞的体现在，BIO的后端线程需要阻塞等待客户端写数据(比如read方法)，如果客户端不写数据线程就要阻塞，NIO把等待客户端操作的事情交给了 selector。selector 负责轮询所有已注册的客户端，监听到有事件发生了才转交给后端线程处理，后端线程不需要做任何阻塞等待，直接处理客户端事件的数据即可，处理完马上结束，或返回线程池供其他客户端事件继续使用。还有 channel 的读写也是非阻塞的。

Redis就是典型的NIO线程模型，selector收集所有连接的事件并且转交给后端线程，线程连续执行所有事件命令并将结果写回客户端；

 AIO（NIO 2.0）

异步非阻塞， 由操作系统完成后回调通知服务端程序启动线程去处理， 一般适用于连接数较多且连接时间较长的应用；

应用场景

AIO方式适用于连接数目多且连接比较长（重操作） 的架构，JDK7 开始支持；

代码示例

BIO&NIO&AIO对比

同步&异步

同步（synchronous）同步是一种可靠的有序运行机制，当我们进行同步操作时，后续的任务是等待当前调用返回，才会进行下一步。

异步（asynchronous）异步与同步相反，则是这个任务不需要等待当前调用返回，而是通过依靠事件、回调等机制来实现任务间次序关系。

阻塞&非阻塞

阻塞（blocking）在进行阻塞操作时，当前线程会处于阻塞状态，无法从事其他任务，只有当条件满足才能继续，比如数据读取、写入操作完成。

非阻塞（non-blocking）非阻塞则是不管IO操作是否结束，直接返回，相应操作在后台继续处理。

刘总Java
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java IO模型：BIO、NIO、AIO讲解
流楚丶格念的博客
10-17 1875
IO，Input/Output 简写，是指内存和外设之间的数据复制的过程。输入是指数据从外设复制到内存中， 输出则是指数据从内存复制到外设。目前，IO 可以通过数据流、序列化和文件系统为系统提供输入和输出而Java中IO是以流为基础进行输入输出的，所有数据被串行化写入输出流，或者从输入流读入。Java IO的方式通常分为几种，同步阻塞的BIO、同步非阻塞的NIO、异步非阻塞的AIO。
Java编程中的IO模型详解：BIO，NIO，AIO的区别与实际应用场景分析
最新发布
01-04
IO模型决定了数据的传输方式，Java支持BIO，NIO，AIO三种IO模型。BIO是同步阻塞模型，特点是一对一的客户端与处理线程关系，适用场景是连接数量较小并且固定的，优点是编程简单，但对服务器资源要求高。NIO是同步非...
Java网络编程-IO模型篇之从BIO、NIO、AIO到内核select、epoll剖析！
m0_73257876的博客
08-18 586
在前面咱们详细叙述了Linux五种IO模型以及Java所提供的三种IO模型支持，对于Java-IO这块内容，阻塞、非阻塞、同步、异步等这些区别就不再聊了，认真看下来本文后自然会有答案，最后是需要重点表明一点： NIO、AIO都是单线程处理多个连接，但并不代表着说永远只有一条线程对网络连接进行处理，这里所谓的单线程处理多个连接，其实本质上是指单条线程接收客户端连接。从上述这段话中应该可以得知：本质上对于客户端的网络连接照样会启动多条线程处理，只不过与BIOJava-BIO。...
Java IO 模型之 BIO，NIO，AIO
cr7258的博客
03-21 130
BIO（Blocking IO） BIO 是同步阻塞模型，一个客户端连接对应一个处理线程。 缺点： 1.BIO 代码里的 accept() 和 read() 方法是阻塞方法，如果没有客户端连接或者连接不做数据读写操作会导致线程阻塞，浪费资源。 2.如果线程很多，会导致服务器线程太多，压力太大，比如 C10K 问题。 应用场景：BIO 适合用于连接数比较小且固定的架构，这种方式对服务器资源要求比较高，但程序简单易理解。 package com.chengzw.bio; import java.io.I
京东数科面试真题：常见的 IO 模型有哪些？Java 中的 BIO、NIO、AIO 有啥区别？
Java烂猪皮
03-19 252
面试中经常喜欢问的一个问题，因为通过这个问题，面试官可以顺便了解一下你的操作系统的水平。 IO 模型这块确实挺难理解的，需要太多计算机底层知识。写这篇文章用了挺久，就非常希望能把我所知道的讲出来吧!希望朋友们能有收货！为了写这篇文章，还翻看了一下《UNIX 网络编程》这本书，太难了，我滴乖乖！心痛~ 个人能力有限。如果文章有任何需要补充/完善/修改的地方，欢迎在评论区指出，共同进步！ 前言 I/O 一直是很多小伙伴难以理解的一个知识点，这篇文章我会将我所理解的 I/O 讲给你听，希望可以对你有所帮助
Java中的IO模式（BIO、NIO、AIO）
weixin_43968383的博客
04-23 543
Java的IO演进 java网络编程的三种IO模型：BIO、NIO、AIO BIO 特点：同步并阻塞 实现模式：一个连接一个线程 具体细节：当客户端有连接请求时，服务器会单独启动一个线程进行处理，这个线程是同步的 缺点：如果连接不做任何事情的话，会造成不必要的线程开销 使用场景：连接数量较小，架构固定 NIO 支持：JDK1.4 特点：同步非阻塞 实现模式：多个连接一个线程 具体细节：当客户端有连接请求时，其请求会被注册到多路复用器上，多路复用器轮询到连接有IO请求就会进行处理 使用场景：连接数量较多，连接
java的IO模式(BIO,NIO,AIO).emmx
07-18
使用mindmaster打开
java BIO NIO AIO
07-18
java的bio nio aio 几种io的详细解释
Java中网络IO的实现方式（BIO、NIO、AIO）介绍
08-31
主要介绍了Java中网络IO的实现方式（BIO、NIO、AIO）介绍的相关资料,需要的朋友可以参考下
Java中的网络IO模型：BIO/NIO/AIO
sun_tantan的博客
08-19 294
目录Java IO类型Java网络IO模型：BIO/NIO/AIO1. Java BIO（同步阻塞）2. Java NIO（同步非阻塞）3. Java AIO（异步非阻塞）BIO、NIO、AIO 适用场景分析 Java IO类型 Java IO常见使用场景 磁盘操作: File 字节操作: InputStream 和 OutputStream 字符操作: Reader 和 Writer 对象操作: Serializable 网络操作 Java 中的网络支持 InetAddress: 用于表示网络上的硬
JAVA浅析之IO模型 BIO/NIO
清风扶柳
12-21 322
一 JAVA中的IO模型 java中的IO模型主要分为三大类：BIO/NIO/AIO。 BIO ：阻塞IO。 NIO : 阻塞/非阻塞IO。 AIO ：异步非阻塞IO。 概念这种东西这里我就不做过多的描述，接下来我们根据实际的案例来分析下BIO和NIO。 二 BIO/NIO的实际案例 一 BIO BIO的案例代码如下： public class BioServer { priv...
Java网络编程IO模型 --- BIO、NIO、AIO详解
wanghuichen的博客
02-15 2913
通俗易懂详解 -- Java网络编程IO模型 BIO、NIO、AIO
JAVA中IO流模型BIO,NIO,AIO
weixin_30378623的博客
03-07 198
一。BIO,NIO,AIO简介要弄懂这些io模型必须弄懂以下这些概念同步:的是用户进程触发IO操作并等待或者轮询的去查看IO操作是否就绪 比如火车站出站口等待来深圳过年的父母 只有接到父母才能做其他事情 等待过程 不停的电话父母 火车是否到站 是否出站 直到接到父母异步:指用户进程触发IO操作以后便开始做自己的事情，而当IO操作已经完成的时候会得到IO完成的通知（...
Linux的五种IO模型与Java的BIO、NIO、AIO
relife
01-26 972
0. 前言 要搞懂IO的发展，首先要先了解以下几个概念 阻塞：发起的请求调用者要等待返回结果，否则当前线程无法处理其他事物。 非阻塞：发起的请求调用者不要等待返回结果，否可以处理其他事物。 同步：发起一个调用后，被调用者处理完请求之前，调用不返回。 异步：发起一个调用后，调用者先返回已接到申请，再通过事件，回调等机制来通知调用者其返回结果。 阻塞非阻塞区别在于，调用者需不需等待结果，才能处理其他事情，同步和异步，在于结果是通过调用返回的，还是通过事件回调等机制来通知调用者返回结果的。 通俗来讲，只有同步阻塞
Linux五种IO模型，java原生BIO、NIO和AIO
一颗小陨石的博客
05-06 838
文章目录一、同步和异步二、阻塞和非阻塞三、组合3.1. 同步阻塞3.2.同步非阻塞3.3 异步阻塞3.4.异步非阻塞:四、五种I/O模型4.1 BIO4.2 NIO4.3 IO复用4.4 信号驱动IO【了解】4.5 异步IO【了解】五个模型比较五、select、poll和epoll的区别Level_triggered(水平触发)Edge_triggered(边缘触发）六、JDK原生BIO：Serv...
四、09【Java常用类】之Java泛型
刘总Java
09-28 660
今天的博客主题 Java常用类——》Java泛型 Java泛型 Java泛型是在 JDK1.5 提出的一个新特性。 其本质就是：参数化类型，也就是所操作的数据类型被指定为一个参数。 参数我们知道，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。 那参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。 泛型允许对类型进行抽象。 最常...
四、08【Java常用类】之Java集合类Map接口
刘总Java
08-30 640
Map public interface Map<K,V> { ... } Map接口描述 将键映射到值的对象。映射不能包含重复的键；每个键最多只能映射到一个值。 这个接口取代了Dictionary类，Dictionary类是一个完全抽象的类，而不是接口。 映射接口提供三个集合视图，允许将映射的内容视为一组键、一组值或一组键-值映射。映射的顺序定义为映射集合视图上的迭代器返回其元素的顺序。一些映射实现，比如TreeMap类，对它们的顺序做出了特定的保证；其他的，比如HashMap
六、04【Java 多线程】之并发编程
刘总Java
08-16 400
并行和并发的概念我们之前有提到过。在回顾下并发：多个任务在同一个 CPU 核上，按细分的时间片轮流(交替)执行，从逻辑上来看那些任务是同时执行。并行：单位时间内，多个处理器或多核处理器同时处理多个任务，是真正意义上的同时进行。那么在多线程编程实战中，线程的个数往往大于CPU的个数，所以一般都称为多线程并发编程而不是多线程并行编程。在多核CPU时代的到来打破了单核CPU对多线程效能的限制。...
四、03【Java常用类】之Math类 & Number类 & BigDecimal类
刘总Java
04-19 377
今天的博客主题 Java常用类——》Math类 & Number类 & BigDecimal类 Math 用于执行基本数学运算的属性和方法，如初等指数、对数、平方根和三角函数。 Math 的方法都被定义为 static 形式，通过 Math 类可以直接调用。 常用API 详细API地址：https://docs.oracle.com/javase/8/d...
java 中的 bio、nio、aio
07-28
Java中的BIO、NIO和AIO是Java语言对操作系统的各种IO模型的封装。在文件处理时，Java的IO API实际上依赖于操作系统层面的IO操作实现。\[1\] BIO（Blocking I/O）是一种同步阻塞的I/O模式，数据的读取和写入必须阻塞...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值