BIO/NIO/AIO

于 2022-10-19 11:03:09 发布
阅读量219 收藏
点赞数
分类专栏： JAVA基础 netty 文章标签： nio
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47188125/article/details/127401863
版权

目录

一：BIO

二：NIO(Non Blocking IO)

三：多路复用器

（1）多路复用器的select方法是如何找到事件channle的？

（2）epoll方法是如何找到事件channel的

四：AIO(NIO 2.0)

五：为什么Netty使用NIO而不是AIO？

一：BIO

同步阻塞模型，一个客户端连接对应一个处理线程

public class SocketServer {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(9000);
        while (true) {
            System.out.println("等待连接。。");
            //阻塞方法
            Socket clientSocket = serverSocket.accept();
            System.out.println("有客户端连接了。。");
            handler(clientSocket);

            /*new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        handler(clientSocket);
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }).start();*/
        }
    }

    private static void handler(Socket clientSocket) throws IOException {
        byte[] bytes = new byte[1024];
        System.out.println("准备read。。");
        //接收客户端的数据，阻塞方法，没有数据可读时就阻塞
        int read = clientSocket.getInputStream().read(bytes);
        System.out.println("read完毕。。");
        if (read != -1) {
            System.out.println("接收到客户端的数据：" + new String(bytes, 0, read));
        }
        clientSocket.getOutputStream().write("HelloClient".getBytes());
        clientSocket.getOutputStream().flush();
    }
}
//客户端代码
public class SocketClient {
    public static void main(String[] args) throws IOException {
        Socket socket = new Socket("localhost", 9000);
        //向服务端发送数据
        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();
    }
}

缺点：

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

2、如果线程很多，会导致服务器线程太多，压力太大，比如C10K问题

应用场景：

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

二：NIO(Non Blocking IO)

同步非阻塞，服务器实现模式为一个线程可以处理多个请求(连接)，客户端发送的连接请求都会注册到多路复用器selector上，多路复用器轮询到连接有IO请求就进行处理，JDK1.4开始引入。

应用场景：

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


public class NioServer {

    // 保存客户端连接
    static List<SocketChannel> channelList = new ArrayList<>();

    public static void main(String[] args) throws IOException, InterruptedException {

        // 创建NIO ServerSocketChannel,与BIO的serverSocket类似
        ServerSocketChannel serverSocket = ServerSocketChannel.open();
        serverSocket.socket().bind(new InetSocketAddress(9000));
        // 设置ServerSocketChannel为非阻塞
        serverSocket.configureBlocking(false);
        System.out.println("服务启动成功");

        while (true) {
            // 非阻塞模式accept方法不会阻塞，否则会阻塞
            // NIO的非阻塞是由操作系统内部实现的，底层调用了linux内核的accept函数
            SocketChannel socketChannel = serverSocket.accept();
            if (socketChannel != null) { // 如果有客户端进行连接
                System.out.println("连接成功");
                // 设置SocketChannel为非阻塞
                socketChannel.configureBlocking(false);
                // 保存客户端连接在List中
                channelList.add(socketChannel);
            }
            // 遍历连接进行数据读取
            Iterator<SocketChannel> iterator = channelList.iterator();
            while (iterator.hasNext()) {
                SocketChannel sc = iterator.next();
                ByteBuffer byteBuffer = ByteBuffer.allocate(128);
                // 非阻塞模式read方法不会阻塞，否则会阻塞
                int len = sc.read(byteBuffer);
                // 如果有数据，把数据打印出来
                if (len > 0) {
                    System.out.println("接收到消息：" + new String(byteBuffer.array()));
                } else if (len == -1) { // 如果客户端断开，把socket从集合中去掉
                    iterator.remove();
                    System.out.println("客户端断开连接");
                }
            }
        }
    }
}

总结：如果连接数太多的话，会有大量的无效遍历，假如有10000个连接，其中只有1000个连接有写数据，但是由于其他9000个连接并没有断开，我们还是要每次轮询遍历一万次，其中有十分之九的遍历都是无效的，这显然不是一个让人很满意的状态。 

通过引入多路复用器就可以解决这个问题

三：多路复用器

  1. 创建ServerSocketChannel
  2. 设置ServerSocketChannel  为非阻塞
  3. 打开Selector 多路复用器
  4. 把ServerSocketChannel  注册到 Selector上
  5. 阻塞 等待需要处理的事件发送
  6. 获取所有已经发送的事件selectionKeys
  7. 开始遍历selectionKeys
  8. 判断事件 是不是 连接事件 （连接客户端）  --->key.isAcceptable()
  9. 否则else if (key.isReadable()) // 如果是OP_READ事件，则进行读取和打印
public class NioSelectorServer {

    public static void main(String[] args) throws IOException, InterruptedException {

        // 创建NIO ServerSocketChannel
        ServerSocketChannel serverSocket = ServerSocketChannel.open();
        serverSocket.socket().bind(new InetSocketAddress(9000));
        // 设置ServerSocketChannel为非阻塞
        serverSocket.configureBlocking(false);
        // 打开Selector处理Channel，即创建epoll
        Selector selector = Selector.open();
        // 把ServerSocketChannel注册到selector上，并且selector对客户端accept连接操作感兴趣
        serverSocket.register(selector, SelectionKey.OP_ACCEPT);
        System.out.println("服务启动成功");

        while (true) {
            // 阻塞等待需要处理的事件发生
            selector.select();

            // 获取selector中注册的全部事件的 SelectionKey 实例
            // 也是就拿到有 事件 发送的内部的集合
            Set<SelectionKey> selectionKeys = selector.selectedKeys();
            Iterator<SelectionKey> iterator = selectionKeys.iterator();

            // 遍历SelectionKey对事件进行处理
            while (iterator.hasNext()) {
                SelectionKey key = iterator.next();
                // 如果是OP_ACCEPT事件，则进行连接获取和事件注册
                if (key.isAcceptable()) {
                    ServerSocketChannel server = (ServerSocketChannel) key.channel();
                    SocketChannel socketChannel = server.accept();
                    socketChannel.configureBlocking(false);
                    // 这里只注册了读事件，如果需要给客户端发送数据可以注册写事件
                    socketChannel.register(selector, SelectionKey.OP_READ);
                    System.out.println("客户端连接成功");
                } else if (key.isReadable()) {  // 如果是OP_READ事件，则进行读取和打印
                    SocketChannel socketChannel = (SocketChannel) key.channel();
                    ByteBuffer byteBuffer = ByteBuffer.allocate(128);
                    int len = socketChannel.read(byteBuffer);
                    // 如果有数据，把数据打印出来
                    if (len > 0) {
                        System.out.println("接收到消息：" + new String(byteBuffer.array()));
                    } else if (len == -1) { // 如果客户端断开连接，关闭Socket
                        System.out.println("客户端断开连接");
                        socketChannel.close();
                    }
                }
                //从事件集合里删除本次处理的key，防止下次select重复处理
                iterator.remove();
            }
        }
    }
}

 

NIO 有三大核心组件： Channel(通道)， Buffer(缓冲区)，Selector(多路复用器)

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

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

3、NIO 的 Buffer 和 channel 都是既可以读也可以写

 

NIO底层在JDK1.4版本是用linux的内核函数select()或poll()来实现，跟上面的NioServer代码类似，selector每次都会轮询所有的sockchannel看下哪个channel有读写事件，有的话就处理，没有就继续遍历，JDK1.5开始引入了epoll基于事件响应机制来优化NIO。

NioSelectorServer 代码里如下几个方法非常重要解下

Selector.open() //创建多路复用器

socketChannel.register(selector, SelectionKey.OP_READ) //将channel注册到多路复用器上

selector.select() //阻塞等待需要处理的事件发生

（1）多路复用器的select方法是如何找到事件channle的？

是遍历所有的channel，拿到有事件的channel

（2）epoll方法是如何找到事件channel的

如果有事件发送，那么它会自己把channel事件 放过来，放到list集合里面去

四：AIO(NIO 2.0)

  • 同步，简单的说就是所有的事情都是我自己干
  • 异步，就是前面连接的事情我来干，后续的其他回调，交给其他异步线程去做

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

public class AIOServer {

    public static void main(String[] args) throws Exception {
        final AsynchronousServerSocketChannel serverChannel =
                AsynchronousServerSocketChannel.open().bind(new InetSocketAddress(9000));

        serverChannel.accept(null, new CompletionHandler<AsynchronousSocketChannel, Object>() {
            @Override
            public void completed(AsynchronousSocketChannel socketChannel, Object attachment) {
                try {
                    System.out.println("2--"+Thread.currentThread().getName());
                    // 再此接收客户端连接，如果不写这行代码后面的客户端连接连不上服务端
                    serverChannel.accept(attachment, this);
                    System.out.println(socketChannel.getRemoteAddress());
                    ByteBuffer buffer = ByteBuffer.allocate(1024);
                    socketChannel.read(buffer, buffer, new CompletionHandler<Integer, ByteBuffer>() {
                        @Override
                        public void completed(Integer result, ByteBuffer buffer) {
                            System.out.println("3--"+Thread.currentThread().getName());
                            buffer.flip();
                            System.out.println(new String(buffer.array(), 0, result));
                            socketChannel.write(ByteBuffer.wrap("HelloClient".getBytes()));
                        }

                        @Override
                        public void failed(Throwable exc, ByteBuffer buffer) {
                            exc.printStackTrace();
                        }
                    });
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            @Override
            public void failed(Throwable exc, Object attachment) {
                exc.printStackTrace();
            }
        });

        System.out.println("1--"+Thread.currentThread().getName());
        Thread.sleep(Integer.MAX_VALUE);
    }
}

五：为什么Netty使用NIO而不是AIO？

在Linux系统上，AIO的底层实现仍使用Epoll，没有很好实现AIO，因此在性能上没有明显的优势，而且被JDK封装了一层不容易深度优化，Linux上AIO还不够成熟。Netty是异步非阻塞框架，Netty在NIO上做了很多异步的封装。

 （言外之意就是AIO是在Epoll上封装，使用netty还需要在AIO基础上继续封装，太多封装没办法做深度优化）

红茶晚报丶
关注
专栏目录
从Linux五种IO模型到JAVA NIO，一文理解IO模型的本质
KDLin‘s Blog
12-27 479
BIO,NIO 2020年12月25日 15:01 目录 - - 引言 - Linux中五种IO模型 - 预备知识 - 阻塞式I/O - 非阻塞IO模型 - IO复用模型 - 信号驱动的IO模型 - 异步IO模型 - JAVA中的IO模型 - BIO - NIO - 三大模块： ...
理解BIO/NIO的基本模型
05-28 292
名称的理解 BIO（Block-IO）：（同步）阻塞IO NIO（No-Block IO）: （同步）非阻塞IO AIO（asynch IO）：异步（非阻塞）IO 从标题中我们可以看出主要差异点是：阻塞/非阻塞、同步/异步 ， 理解这个问题的核心主要就在于理解：阻塞与非阻塞、同步与异步的差异究竟是什么。 PS：看的时候带着问题思考下，为什么没有ANIO（异步阻塞IO）? 阻塞与非阻塞 首先，我们先下个概述定义，阻塞非阻塞说的是线程的状态。 我们先从代码上看看关键的Blokc点，当我们申明Se
Java网络编程和NIO详解7：浅谈 Linux 中NIO Selector 的实现原理
Java技术江湖
07-07 1366
浅谈 Linux 中 Selector 的实现原理 转自：https://www.jianshu.com/p/2b71ea919d49 概述 Selector是NIO中实现I/O多路复用的关键类。Selector实现了通过一个线程管理多个Channel，从而管理多个网络连接的目的。 Channel代表这一个网络连接通道，我们可以将Channel注册到Selector中以实现Sele...
从Linux内核理解JAVA的NIO
Wanguyunxiaodaniu的博客
07-12 928
title: 从Linux内核理解JAVA的NIO top: true cover: true toc: true mathjax: true date: 2020-07-11 12:29:29 password: summary: java nio tags: java,java nio categories: java,java nio img: http://oss.mflyyou.cn/blog/20200712170908.png?author=zhangpanqin 前言 IO 可以简单分为.
java中的BIO、NIO、AIO，Hotspot源码与Linux内核理解NIO与Epoll，同步异步与阻塞非阻塞区别
qq_43206800的博客
06-02 271
IO模型 IO模型就是说用什么样的通道进行数据的发送和接收，Java共支持3种网络编程IO模式：BIO，NIO，AIO 原始的没有优化的IO BIO(Blocking IO) 同步阻塞模型，一个客户端连接对应一个处理线程 代码，多线程优化的BIO public class SocketServer { public static void main(String[] args) throws IOException { ServerSocket serverSocket = ne
java nio linux,走进Java NIO的世界
weixin_33705384的博客
05-07 202
Java NIO 简介Java NIO，即Java New IO,是Java IO的2.0版本，since from JDK1.4。JDK1.4以前提供的都是传统的IO，即我们经常使用的InputStream/OutputStream/Reader/Writer等。对于传统IO，我们可以利用流的装饰功能，使其具有Buffer功能，本质上是利用byte[]完成的。而Java NIO单独把Buffer...
深度讲解：同步/异步/阻塞/非阻塞/BIO/NIO/AIO
01-19
常规的误区 ... ... 　这个时候你问别人，刚刚代码发起的这个请求是不是一个同步请求，对方一定回答是。这是对的，它确实是。...对方一定是这样回答的，“因为发起请求后，代码就卡住不动了，直到拿到响应后才可以继续往下...
一站式学习Java网络编程 全面理解BIO:NIO:AIO1
08-08
全面理解 Java 网络编程 - BIO、NIO、AIO 本课程旨在帮助学生全面理解 Java 网络编程中的 BIO、NIO、AIO 三剑客，掌握 RPC 编程的基础知识，并结合实战项目巩固所学。 一、网络编程三剑客 - BIO、NIO、AIO BIO...
详解Java 网络IO编程总结（BIO、NIO、AIO均含完整实例代码）
08-28
Java 网络IO编程总结（BIO、NIO、AIO均含完整实例代码） Java 网络IO编程是 Java 编程语言中最重要的知识点之一，涉及到网络编程的各种技术和模型。本篇文章主要介绍了 Java 网络IO编程总结，包括 BIO、NIO 和 AIO ...
JAVA BIO AIO NIO测试代码
09-01
对java io总结时编写的测试代码，包括BIO,NIO,AIO的实现，Java io操作是编程人员经常使用到的，以前只是使用没有对这三种IO做系统的了解，本文将对这三种IO作详细的介绍并附有测试完整代码
一文从Linux内核理解JAVA的NIO
m0_73494896的博客
09-02 227
IO 可以简单分为磁盘 IO和网络 IO,磁盘 IO相对于网络 IO速度会快一点，本文主要介绍磁盘 IO，网络 IO下周写。JAVA 对NIO抽象为Channel,Channel又可以分为（磁盘 io）和（网络 io）。如果你对 IO 的理解只是停留在 api 层面那是远远不够的，一定要了解 IO 在系统层面是怎么处理的，避免掉进一些不必要的坑。FileChannel 读写复制文件的用法。ByteBuffer 的介绍jvm 文件进程锁，FileLock。
java bio，nio，aio及源码
陈钊的博客
01-05 1713
NIO学习笔记简介 随着JavaIO类库的不断发展和改进，基于Java的网络编程会变得越来越简单。随着异步IO功能的增强，基于JavaNIO开发的网络服务器甚至不逊色与C++开发的网络程序。 记录一下学习BIO、NIO编程模型以及JDK1.7提供的NIO2.0的使用。 传统的BIO编程 这个可以搜索一下socket，就有很多。 通过一个线程来监听所有的socket连接，连接成功则新建线程去处理客户端
Linux的五种IO模型与Java的BIO、NIO、AIO
relife
01-26 1084
0. 前言 要搞懂IO的发展，首先要先了解以下几个概念 阻塞：发起的请求调用者要等待返回结果，否则当前线程无法处理其他事物。 非阻塞：发起的请求调用者不要等待返回结果，否可以处理其他事物。 同步：发起一个调用后，被调用者处理完请求之前，调用不返回。 异步：发起一个调用后，调用者先返回已接到申请，再通过事件，回调等机制来通知调用者其返回结果。 阻塞非阻塞区别在于，调用者需不需等待结果，才能处理其他事情，同步和异步，在于结果是通过调用返回的，还是通过事件回调等机制来通知调用者返回结果的。 通俗来讲，只有同步阻塞
Java网络编程-IO模型篇之从BIO、NIO、AIO到内核select、epoll剖析
JHIII的博客
08-13 223
在前面咱们详细叙述了Linux五种IO模型以及Java所提供的三种IO模型支持，对于Java-IO这块内容，阻塞、非阻塞、同步、异步等这些区别就不再聊了，认真看下来本文后自然会有答案，最后是需要重点表明一点： NIO、AIO都是单线程处理多个连接，但并不代表着说永远只有一条线程对网络连接进行处理，这里所谓的单线程处理多个连接，其实本质上是指单条线程接收客户端连接。从上述这段话中应该可以得知：本质上对于客户端的网络连接照样会启动多条线程处理，只不过与BIOJava-BIO。...
BIO到NIO源码的一些事儿之NIO 下 Buffer解读 下
weixin_34102807的博客
02-14 547
前言 此系列文章会详细解读NIO的功能逐步丰满的路程，为Reactor-Netty 库的讲解铺平道路。 关于Java编程方法论-Reactor与Webflux的视频分享，已经完成了Rxjava 与 Reactor，b站地址如下: Rxjava源码解读与分享：www.bilibili.com/video/av345… Reactor源码解读与分享：www.bilibili.com/video/av3...
IO网络模型分析
debug
01-01 393
关于IO模型，网上有很多说法文章，很容易的看晕，并且对于NIO，IO多路复用，Reactor等术语有不同的解释；本人建议先不关注上面这些问题，先从存在的问题入手，再找到解决问题的方法，然后分析优点和缺点，再不断优化。 BIO(同步阻塞) BIO：block input/output 同步阻塞IO 同步：指的是在客户端请求服务端，并建立连接，此时在服务端处理完当前客户端的请求之后才能接受下一个客户端的请求 阻塞：指的是服务端的ServerSocket是阻塞模式的，并且IO也会造成阻塞 public stati
java中断机制深入分析之Thread源码跟踪
Saintyyu的博客
08-02 710
Thread.interrupt()源码中有这样一句注释：Just to set the interrupt flag。如果说Thread.interrupt()方法只是修改了中断标记_interrupted的值，那么已经放弃cpu、处于阻塞状态的thread线程如何能感知到这个变量已经被改变，从而立即抛出InterruptedException呢？真相只有一个，那就是这个注释是错的！！！
java IO模型
Ke_dragon的博客
06-08 336
学习netty之前需要学习的铺垫内容
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值