java中的BIO、NIO、AIO，Hotspot源码与Linux内核理解NIO与Epoll，同步异步与阻塞非阻塞区别

最新推荐文章于 2022-09-02 16:38:46 发布
最新推荐文章于 2022-09-02 16:38:46 发布
阅读量279 收藏 3
点赞数 2
分类专栏： JAVAEE 文章标签： java socket 多线程 redis linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43206800/article/details/117473639
版权

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 = new ServerSocket(9000);
        while (true) {
            System.out.println("等待连接。。");
            //阻塞方法
            Socket clientSocket = serverSocket.accept();
            System.out.println("有客户端连接了。。");
            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, InterruptedException {
        Socket socket = new Socket("127.0.0.1", 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请求就进行处理

应用场景：

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

public class NioServer {

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

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

        // 创建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("客户端断开连接");
                }
            }
        }
    }
}

read不会阻塞
在这里插入图片描述
在这里插入图片描述

总结：

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

NIO引入多路复用器

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;
import java.util.Set;

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

NIO重要的API
Selector.open()  //创建多路复用器
 socketChannel.register(selector, SelectionKey.OP_READ)  //将channel注册到多路复用器上
selector.select()  //阻塞等待需要处理的事件发生

在这里插入图片描述

总结

NIO整个调用流程就是Java调用了操作系统的内核函数来创建Socket，获取到Socket的文件描述符，再创建一个Selector对象，对应操作系统的Epoll描述符，将获取到的Socket连接的文件描述符的事件绑定到Selector对应的Epoll文件描述符上，进行事件的异步通知，这样就实现了使用一条线程，并且不需要太多的无效的遍历，将事件处理交给了操作系统内核(操作系统中断程序实现)，大大提高了效率。
在这里插入图片描述

AIO(NIO 2.0)

异步非阻塞， 由操作系统完成后回调通知服务端程序启动线程去处理， 一般适用于连接数较多且连接时间较长的应用
同步：一个线程干完所有（NIO），异步：每个线程干自己的

在这里插入图片描述

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousServerSocketChannel;
import java.nio.channels.AsynchronousSocketChannel;
import java.nio.channels.CompletionHandler;

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);
    }
}

import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousSocketChannel;

public class AIOClient {

    public static void main(String... args) throws Exception {
        AsynchronousSocketChannel socketChannel = AsynchronousSocketChannel.open();
        socketChannel.connect(new InetSocketAddress("127.0.0.1", 9000)).get();
        socketChannel.write(ByteBuffer.wrap("HelloServer".getBytes()));
        ByteBuffer buffer = ByteBuffer.allocate(512);
        Integer len = socketChannel.read(buffer).get();
        if (len != -1) {
            System.out.println("客户端收到信息：" + new String(buffer.array(), 0, len));
        }
    }
}
BIO、 NIO、 AIO 对比：

在这里插入图片描述

同步异步与阻塞非阻塞(段子)

老张爱喝茶，废话不说，煮开水。
出场人物：老张，水壶两把（普通水壶，简称水壶；会响的水壶，简称响水壶）。
1 老张把水壶放到火上，立等水开。（同步阻塞）
老张觉得自己有点傻
2 老张把水壶放到火上，去客厅看电视，时不时去厨房看看水开没有。（同步非阻塞）
老张还是觉得自己有点傻，于是变高端了，买了把会响笛的那种水壶。水开之后，能大声发出嘀~~~~的噪音。
3 老张把响水壶放到火上，立等水开。（异步阻塞）
老张觉得这样傻等意义不大
4 老张把响水壶放到火上，去客厅看电视，水壶响之前不再去看它了，响了再去拿壶。（异步非阻塞）
老张觉得自己聪明了。

所谓同步异步，只是对于水壶而言。
普通水壶，同步；响水壶，异步。
虽然都能干活，但响水壶可以在自己完工之后，提示老张水开了。这是普通水壶所不能及的。
同步只能让调用者去轮询自己（情况2中），造成老张效率的低下。
所谓阻塞非阻塞，仅仅对于老张而言。
立等的老张，阻塞；看电视的老张，非阻塞。

hidecode
关注
专栏目录
（2021）Java架构师面试题汇总
知识改变命运，ヾ(◍°∇°◍)ﾉﾞ【求关注】
08-20 2264
面试题汇总，答案继续中
从Linux五种IO模型到JAVA NIO，一文理解IO模型的本质
KDLin‘s Blog
12-27 497
BIO,NIO 2020年12月25日 15:01 目录 - - 引言 - Linux中五种IO模型 - 预备知识 - 阻塞式I/O - 非阻塞IO模型 - IO复用模型 - 信号驱动的IO模型 - 异步IO模型 - JAVA中的IO模型 - BIO - NIO - 三大模块： ...
Java网络编程和NIO详解7：浅谈 Linux 中NIO Selector 的实现原理
Java技术江湖
07-07 1369
浅谈 Linux 中 Selector 的实现原理 转自：https://www.jianshu.com/p/2b71ea919d49 概述 Selector是NIO中实现I/O多路复用的关键类。Selector实现了通过一个线程管理多个Channel，从而管理多个网络连接的目的。 Channel代表这一个网络连接通道，我们可以将Channel注册到Selector中以实现Sele...
从Linux内核理解JAVA的NIO
Wanguyunxiaodaniu的博客
07-12 938
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 nio linux,走进Java NIO的世界
weixin_33705384的博客
05-07 209
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...
一文从Linux内核理解JAVA的NIO
m0_73494896的博客
09-02 239
IO 可以简单分为磁盘 IO和网络 IO,磁盘 IO相对于网络 IO速度会快一点，本文主要介绍磁盘 IO，网络 IO下周写。JAVA 对NIO抽象为Channel,Channel又可以分为（磁盘 io）和（网络 io）。如果你对 IO 的理解只是停留在 api 层面那是远远不够的，一定要了解 IO 在系统层面是怎么处理的，避免掉进一些不必要的坑。FileChannel 读写复制文件的用法。ByteBuffer 的介绍jvm 文件进程锁，FileLock。
深入理解Java三种IO模式和Epoll模型
Jack 架构师之路
01-27 1875
IO模型 IO模型就是说用什么样的通道进行数据的发送和接收，Java共支持3种网络编程IO模式：BIO，NIO，AIO BIO(Blocking IO ) 同步阻塞模型，一个客户端连接对应一个处理线程 BIO代码示例： import java.net.ServerSocket; import java.net.Socket; import java.util.logging.Handler; public class SocketServer { public static
Java 并发编程解析 | 如何正确理解Java领域中的多线程模型，主要用来解决什么问题?
guanshengg的博客
08-16 307
作为一名Java Developer，在面对Java并发编程的时候，有过哪些的疑惑与不解 ？对于Java领域中的线程机制与多线程，你都做了哪些功课？是否和我一样，在看完《Java编程思想》和《Java并发编程实战》之后，依旧一头雾水，不知其迹？那么，希望你看完此篇文章之后，对你有所帮助...
后端开发基础知识整理JAVA、JVM、操作系统、网络、设计模式、mysql、redis、多线程、spring、springboo
最新发布
03-09
- **缓冲与非缓冲I/O、直接与非直接I/O、阻塞与非阻塞I/O、同步与异步I/O**：不同的I/O操作模式，适应不同的应用场景。 - **DMA工作方式**：直接内存访问，绕过CPU进行数据传输。 - **TCP/IP网络模型**：应用层、...
JAVA BIO AIO NIO测试代码
09-01
对java io总结时编写的测试代码，包括BIO,NIO,AIO的实现，Java io操作是编程人员经常使用到的，以前只是使用没有对这三种IO做系统的了解，本文将对这三种IO作详细的介绍并附有测试完整代码
java bio，nio，aio及源码
陈钊的博客
01-05 1724
NIO学习笔记简介 随着JavaIO类库的不断发展和改进，基于Java的网络编程会变得越来越简单。随着异步IO功能的增强，基于JavaNIO开发的网络服务器甚至不逊色与C++开发的网络程序。 记录一下学习BIO、NIO编程模型以及JDK1.7提供的NIO2.0的使用。 传统的BIO编程 这个可以搜索一下socket，就有很多。 通过一个线程来监听所有的socket连接，连接成功则新建线程去处理客户端
Linux的五种IO模型与Java的BIO、NIO、AIO
relife
01-26 1104
0. 前言 要搞懂IO的发展，首先要先了解以下几个概念 阻塞：发起的请求调用者要等待返回结果，否则当前线程无法处理其他事物。 非阻塞：发起的请求调用者不要等待返回结果，否可以处理其他事物。 同步：发起一个调用后，被调用者处理完请求之前，调用不返回。 异步：发起一个调用后，调用者先返回已接到申请，再通过事件，回调等机制来通知调用者其返回结果。 阻塞非阻塞区别在于，调用者需不需等待结果，才能处理其他事情，同步和异步，在于结果是通过调用返回的，还是通过事件回调等机制来通知调用者返回结果的。 通俗来讲，只有同步阻塞
Java网络编程-IO模型篇之从BIO、NIO、AIO到内核select、epoll剖析
JHIII的博客
08-13 233
在前面咱们详细叙述了Linux五种IO模型以及Java所提供的三种IO模型支持，对于Java-IO这块内容，阻塞、非阻塞、同步、异步等这些区别就不再聊了，认真看下来本文后自然会有答案，最后是需要重点表明一点： NIO、AIO都是单线程处理多个连接，但并不代表着说永远只有一条线程对网络连接进行处理，这里所谓的单线程处理多个连接，其实本质上是指单条线程接收客户端连接。从上述这段话中应该可以得知：本质上对于客户端的网络连接照样会启动多条线程处理，只不过与BIOJava-BIO。...
BIO到NIO源码的一些事儿之NIO 下 Buffer解读 下
weixin_34102807的博客
02-14 550
前言 此系列文章会详细解读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 406
关于IO模型，网上有很多说法文章，很容易的看晕，并且对于NIO，IO多路复用，Reactor等术语有不同的解释；本人建议先不关注上面这些问题，先从存在的问题入手，再找到解决问题的方法，然后分析优点和缺点，再不断优化。 BIO(同步阻塞) BIO：block input/output 同步阻塞IO 同步：指的是在客户端请求服务端，并建立连接，此时在服务端处理完当前客户端的请求之后才能接受下一个客户端的请求 阻塞：指的是服务端的ServerSocket是阻塞模式的，并且IO也会造成阻塞 public stati
java中断机制深入分析之Thread源码跟踪
Saintyyu的博客
08-02 726
Thread.interrupt()源码中有这样一句注释：Just to set the interrupt flag。如果说Thread.interrupt()方法只是修改了中断标记_interrupted的值，那么已经放弃cpu、处于阻塞状态的thread线程如何能感知到这个变量已经被改变，从而立即抛出InterruptedException呢？真相只有一个，那就是这个注释是错的！！！
java IO模型
Ke_dragon的博客
06-08 349
学习netty之前需要学习的铺垫内容
Java网络编程-IO模型篇之从BIO、NIO、AIO到内核select、epoll剖析！
guanshengg的博客
08-13 374
在前面咱们详细叙述了Linux五种IO模型以及Java所提供的三种IO模型支持，对于Java-IO这块内容，阻塞、非阻塞、同步、异步等这些区别就不再聊了，认真看下来本文后自然会有答案，最后是需要重点表明一点： NIO、AIO都是单线程处理多个连接，但并不代表着说永远只有一条线程对网络连接进行处理，这里所谓的单线程处理多个连接，其实本质上是指单条线程接收客户端连接。从上述这段话中应该可以得知：本质上对于客户端的网络连接照样会启动多条线程处理...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值