IO模型-bio 多路复用epoll

最新推荐文章于 2023-02-16 18:06:22 发布
最新推荐文章于 2023-02-16 18:06:22 发布
阅读量221 收藏
点赞数
分类专栏： IO模型系列 文章标签： epoll nio bio aio
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45657738/article/details/112722525
版权
本文深入探讨了BIO（阻塞I/O）、NIO（非阻塞I/O）与AIO（异步I/O）的概念及其在Java中的实现方式。通过对比不同I/O模型的特点，如阻塞与非阻塞、同步与异步，以及它们在实际应用中的表现，帮助读者更好地理解和选择适合的I/O模型。
摘要由CSDN通过智能技术生成

主要研究 NIO与EPOLL
探讨深度 Java代码 -> HotSpot源码 -> linux函数

一. BIO

1 public static void main(String[] args) throws IOException {
2	ServerSocket serverSocket = new ServerSocket(9000);
3	
4	while (true) {
5	    Socket socket = serverSocket.accept();	
6	    byte[] buffer = new byte[1024];
7	    int read = socket.getInputStream().read(buffer);
8	    if (read != 0) {
9	        String data = new String(buffer, 0, read);
10	        System.out.println(data);
11	        OutputStream outputStream = socket.getOutputStream();
12	
13	        outputStream.write(data.getBytes());
14	        outputStream.flush();
15	        socket.close();
	    }
	}
}

终端命令:
在这里插入图片描述
debug启动时, 会发现pc指针会在第5行阻塞, 我们启终端 telnet localhost 9000
指针会继续执行, 再次阻塞在第7行, 这时我们在终端 send bio test, pc会继续执行
期间终端再启一个控制台, 去telnet发现也是被阻塞的 后发送会等第一个执行完再执行后面的

idea console如下:
在这里插入图片描述

二. NIO

  1. 不使用多路复用, 单纯的非阻塞
public static void main(String[] args) throws IOException {
	List<SocketChannel> clientSocketList = new ArrayList<>(1024);
    ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
    serverSocketChannel.socket().bind(new InetSocketAddress(9000));
    serverSocketChannel.configureBlocking(false);

    while (true) {
        SocketChannel clientSocket = serverSocketChannel.accept();
        if (clientSocket != null) {
            clientSocket.configureBlocking(false);
            clientSocketList.add(clientSocket);
        }

        Iterator<SocketChannel> iterator = clientSocketList.iterator();

        while (iterator.hasNext()) {
            SocketChannel sc = iterator.next();
            ByteBuffer dst = ByteBuffer.allocate(1024);
            int len = sc.read(dst);

            if (len > 0) {
                System.out.println("接收到消息： " + new String(dst.array()));
            }
        }
    }
}

从上面代码我们就发现设置了一个很重要的参数configureBlocking(false), 设置为非阻塞, accept和read都不阻塞, 进来的socket都放到了一个容器了, 然后循环便利这个容器, 看是否有inputStream流数据, 有则输出, 继续下次循环.
开启两个终端telnet localhost 9000
第一个send a
第二个send b

IDEA console如下:
在这里插入图片描述

这段代码例子, (可以理解为)就是linux的select的工作原理, 而poll就是把clientSocketList容器的最大值设置为Integer.MAX_VALUE.

  1. 重点在这里!!!
    重点在这里!!!
    重点在这里!!!
    重点在这里!!!
    重点在这里!!!
    使用多路复用Selector
public static void main(String[] args) throws IOException {
    ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
    serverSocketChannel.socket().bind(new InetSocketAddress(9000));
    serverSocketChannel.configureBlocking(false);
    // linux epoll_create
    Selector selector = Selector.open();
    // linux epoll_ctl
    serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

    while (true) {
        // linux epoll_wait rdList epoll的就绪队列有事件 才会继续执行
        selector.select();

        Set<SelectionKey> selectionKeys = selector.selectedKeys();
        Iterator<SelectionKey> iterator = selectionKeys.iterator();


        while (iterator.hasNext()) {
            SelectionKey sk = iterator.next();

            if (sk.isAcceptable()) {
                ServerSocketChannel server = (ServerSocketChannel) sk.channel();
                SocketChannel sc = server.accept();
                sc.configureBlocking(false);
                sc.register(selector, SelectionKey.OP_READ);
                System.out.println("客户端连接成功");
            } else if (sk.isReadable()) {
                SocketChannel sc = (SocketChannel) sk.channel();
                ByteBuffer dst = ByteBuffer.allocate(1024);
                int len = sc.read(dst);

                if (len > 0) {
                    System.out.println("接收到消息： " + new String(dst.array()));
                }
            }
            iterator.remove();
        }
    }
}

第一个终端 telnet localhost 9000
第二个终端 telnet localhost 9000
第一个终端 send a
第二个终端 seng b
第一个终端 send c

IDEA console如下:
在这里插入图片描述

!!! 这段代码, 主要引入了一个在linux运行jdk时候, 就是EPOLL的相关操作. 服务端和连接进来的socket分别注册了OPEN和READ事件, 没有事件时会阻塞在select()方法里, 当有相关事件就会进行接下来的代码逻辑执行.
接下来我们重点看Selector的 open, register, select三个方法, 到底做了什么东西.

// open方法 jdk源码
public static Selector open() throws IOException {
    return SelectorProvider.provider().openSelector();
}

public static SelectorProvider provider() {
    synchronized (lock) {
        if (provider != null)
            return provider;
        return AccessController.doPrivileged(
            new PrivilegedAction<SelectorProvider>() {
                public SelectorProvider run() {
                        if (loadProviderFromProperty())
                            return provider;
                        if (loadProviderAsService())
                            return provider;
                        // 重点create方法 这里直接点进去 会根据下载的jdk pc版本进入不同方法 我们直接去openjdk源码里看Epoll的实现
                        provider = sun.nio.ch.DefaultSelectorProvider.create();
                        return provider;
                    }
                });
    }
}

!!! 源码分析

// open jdk源码
public static SelectorProvider create() {
    String osname = AccessController
        .doPrivileged(new GetPropertyAction("os.name"));
    if (osname.equals("SunOS"))
        return createProvider("sun.nio.ch.DevPollSelectorProvider");
    if (osname.equals("Linux"))
        return createProvider("sun.nio.ch.EPollSelectorProvider");
    // 到这个类里去看
    return new sun.nio.ch.PollSelectorProvider();
}

public class EPollSelectorProvider
    extends SelectorProviderImpl
{
    public AbstractSelector openSelector() throws IOException {
    	// return了一个实现类
        return new EPollSelectorImpl(this);
    }

    public Channel inheritedChannel() throws IOException {
        return InheritedChannel.getChannel();
    }
}

EPollSelectorImpl(SelectorProvider sp) throws IOException {
    super(sp);
    long pipeFds = IOUtil.makePipe(false);
    fd0 = (int) (pipeFds >>> 32);
    fd1 = (int) pipeFds;
    try {
    	// new了一个EPollArrayWrapper
        pollWrapper = new EPollArrayWrapper();
        pollWrapper.initInterrupt(fd0, fd1);
        fdToKey = new HashMap<>();
    } catch (Throwable t) {
        try {
            FileDispatcherImpl.closeIntFD(fd0);
        } catch (IOException ioe0) {
            t.addSuppressed(ioe0);
        }
        try {
            FileDispatcherImpl.closeIntFD(fd1);
        } catch (IOException ioe1) {
            t.addSuppressed(ioe1);
        }
        throw t;
    }
}

// EPollArrayWrapper里
EPollArrayWrapper() throws IOException {
    // creates the epoll file descriptor
    // 我们都知道linux里 一切皆是文件 所以创建了一个epoll
    epfd = epollCreate();

    // the epoll_event array passed to epoll_wait
    int allocationSize = NUM_EPOLLEVENTS * SIZE_EPOLLEVENT;
    pollArray = new AllocatedNativeObject(allocationSize, true);
    pollArrayAddress = pollArray.address();

    // eventHigh needed when using file descriptors > 64k
    if (OPEN_MAX > MAX_UPDATE_ARRAY_SIZE)
        eventsHigh = new HashMap<>();
}

// 三个核心native方法
private native int epollCreate();
private native void epollCtl(int epfd, int opcode, int fd, int events);
private native int epollWait(long pollAddress, int numfds, long timeout, int epfd) throws IOException;

// 我们先拿epollCreate()举例, 我们要去看c语言如何实现这个方法, 那么拿类名加下划线和方法名, 
// EPollArrayWrapper_epollCreate
JNIEXPORT jint JNICALL
Java_sun_nio_ch_EPollArrayWrapper_epollCreate(JNIEnv *env, jobject this)
{
    /*
     * epoll_create expects a size as a hint to the kernel about how to
     * dimension internal structures. We can't predict the size in advance.
     */
     // 就是这个epoll_create linux中的方法 C语言可以直接调用它 
     // 在linux里用man命令可以查看相关方法的详细描述
    int epfd = epoll_create(256);
    if (epfd < 0) {
       JNU_ThrowIOExceptionWithLastError(env, "epoll_create failed");
    }
    return epfd;
}

以上就是selector的open分析 jdk源码 -> hotspot源码 -> linux语法概要
register 对应 epollCtl, epollCtl相当于注册一个事件
select 对应 epollWait, epollWait相当于绑定了这个事件 并且监听

三. AIO

public static void main(String[] args) throws IOException, InterruptedException {
    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);
}

启动第一个终端执行 telnet localhost 9000和send a
启动第二个终端执行 telnet localhost 9000和send b

IDEA console如下:
在这里插入图片描述

BIO, NIO在代码案例中, 都是main线程去执行的, 而这个AIO就是线程如此多.

四. 总结

BIO, NIO, AIO主要的区别分为两个阻塞与非阻塞, 同步与非同步
从第一个和第二个例子, 我们可以理解出阻塞与非阻塞的区别.
从第三个和第四个例子, 我们可以看出同步与非同步的区别.
在这里插入图片描述

1.4之后出现NIO, 先是采用linux的 select 后采用poll
1.5及之后采用了epoll的IO多路复用架构

在这里插入图片描述

不写是真记不住啊
关注
专栏目录
I/O多路复用的详解(包含什么是IO、NIO、BIO以及select、epoll、poll这些方式解答)
m0_46741750的博客
02-02 1218
你要偷偷学技术，超过所有人！
Redis 网络模型 -- 阻塞非阻塞IO、IO多路复用、epoll详解
m0_71777195的博客
10-29 1459
当用户进程调用了select，那么整个进程会被阻塞，而同时，内核会"监视"所有select负责的socket，当任何一个socket中的数据准备好了，select就会返回。这个时候用户进程再调用read操作，将数据从内核拷贝到用户进程。这个模型和阻塞IO的模型其实并没有太大的不同，事实上还更差一些。因为这里需要使用两个系统调用(select和recvfrom)，而阻塞IO只调用了一个系统调用(recvfrom)。但是，用select的优势在于它可以同时处理多个连接。
真实如刀的洞见：NIO,epoll,多路复用，更好地理解IO
公众号：该用户快成仙了
08-27 216
java代码和系统调用有一定的关系，Java是解释型语言（Java并不值钱，值钱的是jvm），我们所写的java代码最终都编译成字节码，然后去进行系统调用，本文我们还是从一个简单的服务端程序学习理解下io。 BIO 无论是哪种语言只要是服务端的程序，一定会有如下操作 调用socket得到文件描述（符代表了这个socket） bind绑定端口如8090 listen 监听状态 accept 接收客户端连接 继续使用上一篇文章的测试demo，通过一个客户端连接服务端，从下面的图片中可以看到主线程到了
NIO和Epoll的实现原理
Mrs_haining的博客
08-25 233
什么是NIO 　　NIO又叫New/Non-blocking IO，这个概念基本人人都听过，但是不一定每个人都懂他它的运行的原理。 　　这里我们来探讨这个问题，先用一个例子解释一下BIO到底阻塞了哪里。 /** * 这是一个单线程BIOServer * @author endless * @create 2020-03-23 */ public class BioServerDemo { public static void main(String[] args) throws IOE
IO模型--从BIO、NIO、AIO到内核select、poll、epoll剖析
最新发布
weixin_49329785的博客
02-16 1616
正是因为 epoll 能自定义监听的描述符数量，以及可以直接返回就绪的描述符，Redis 在设计和实现网络通信框架时，就基于 epoll 机制中的 epoll_create、epoll_ctl 和 epoll_wait 等函数和读写事件，进行了封装开发，实现了用于网络通信的事件驱动框架，从而使得 Redis 虽然是单线程运行，但是仍然能高效应对高并发的客户端访问。NIO是一种基于通道、面向缓冲区的IO操作，相较BIO而言，它能够更为高效的对数据进行读写操作，同时与原先的BIO使用方式也大有不同。
浅谈NIO和Epoll的实现原理
随手笔记
03-25 5629
什么是NIO NIO又叫非阻塞IO，这个概念基本人人都懂，但是不一定每个人都懂他相比BIO到底非阻塞了哪里。 这里我们用一个BIO的例子来探讨这个问题 /** * 这是一个BIOServer * @author endless * @create 2020-03-23 */ public class BioServerDemo { public static void main(S...
详解磁盘IO、网络IO、零拷贝IO、BIO、NIO、AIO、IO多路复用(select、poll、epoll)
雷恩Layne
02-22 5780
文章很长，但是很用心！ 文章目录1. 什么是I/O2. 磁盘IO3. 网络IO4. IO中断与DMA5. 零拷贝IO6. BIO7. NIO8. IO多路复用8.1 select8.2 poll8.3 epoll9. AIO10. 总结 1. 什么是I/O 在计算机操作系统中，所谓的I/O就是输入（Input）和输出（Output），也可以理解为读（Read）和写（Write)，针对不同的对象，I/O模式可以划分为磁盘IO模型和网络IO模型。 IO操作会涉及到用户空间和内核空间的转换，先来理解以下规则：
面试部分难点梳理 - IO多路复用
paleatta的博客
03-22 3914
java-IO：NIO，BIO，AIO，IO多路复用
qq_37442823的博客
09-14 552
IO0. BIO与NIO的区别1. BIO（block IO）：同步阻塞IO2. NIO（no-block IO）：同步非阻塞IONIO框架（New IO）3. AIO（no-block IO）：异步非阻塞IO 0. BIO与NIO的区别 NIO是面向buffer的方式处理数据，BIO是以面向流的形式去写入和读出的。所以在效率上的话，肯定是NIO效率比IO效率会高出很多。 NIO的通道是可以双向的，但是IO中的流只能是单向的。 NIO比传统的BIO核心区别就是，NIO采用的是多路复用的IO模型，普通的IO
网络通信和IO（3）：IO模型 / 什么是BIO / 什么是NIO /什么是多路复用 / epoll实现IO多路复用 / socket详解
qq_40373699的博客
06-19 739
123
NIO AIO BIO及 IO多路复用概述
Ambition_Tn的博客
08-19 425
IO读写的基础原理 ⛽️ 作为一名JAVA开发人员，IO原理和知识是我们需要掌握的基础原理，也是通向大公司面试的必备知识。 用户进程在进行IO的读写操作时，是依赖于底层的IO读写的，通过read和write两大系统调用。 这里需要注意： 1、read系统调用并不是直接将数据从物理设备读取到内存中；而是将内核缓冲区的数据复制到进程缓冲区。 2、write系统调用也不是将数据从内存中写出到物理设备；而是将数据从进程缓冲区写出到用户缓冲区中。 3、上层应用都只是将缓存区中的数据进行复制，而真正与磁盘进行数据交换
BIO NIO AIO IO多路复用
weixin_45225235的博客
02-23 1032
目录   一、基础概念 一、阻塞和非阻塞 二、同步和的异步 三、阻塞非阻塞和同步异步的结合 同步阻塞： 同步非阻塞： 异步阻塞： 异步非阻塞： 二、BIO模型  (Blocking IO)同步阻塞IO  BIO特点 三、NIO模型（Non-blocking IO） NIO特点： 四、IO多路复用模型 IO多路复用和NIO的区别 ...
从BIO到epoll（硬核讲解）
小龙JWY的博客
03-25 3803
老样子，我先放几个问题，你自我检测一下，看看自己掌握多少，再去看我的讲解。 计算机怎么能接收网络信息 SocketException: Too many open files 是什么 同步非阻塞的缺点是什么 仅仅只是非阻塞，是否存在什么问题 什么时候会涉及用户态与内核态的切换 共享空间在网络IO的作用 什么是中断 异步是如何实现的 那 Linux 可以实现异步吗 很多 Java 程序员还停留在...
Epoll在Nio中的实现
nieyanshun_me的专栏
09-01 4502
java nio 和epoll实现
NIO多路复用底层原理(Select、Poll、EPoll)
qq_41563912的博客
09-06 5522
NIO一、NIO概述1. BIO2. NIO二、文件描述符三、Select、Poll、EPoll1. Select2. Poll模型3. EPoll模型四、总结1. 大致过程如下: 一、NIO概述 1. BIO         BIO，即Blockig IO，阻塞IO，一个线程对应一个连接，如果你的服务器有很多用户，每个用户都需要与你的服务器建立一个连接，那么你有多少用户，你的服务器就得创建多少个线程，显然是不显示的，而且每个线
Redis之IO线程、IO多路复用，BIO、NIO和AIO区别
热门推荐
mashaokang1314的博客
03-18 1万+
参考文章：https://blog.csdn.net/Happy_wu/article/details/80052617 redis的线程 redis是单线程操作的，但是却可以处理高并发。原因是基于多路复用的非阻塞IO，基于NIO(non_blocking_io); redis为什么这么快？ 完全基于内存，绝大部分请求是纯粹的内存操作； 数据结构简单，对数据操作也简单，redis中的数据结构是专...
高性能网络服务器编程：为什么linux下epoll是最好，Netty要比NIO.2好？
weixin_33813128的博客
04-10 535
　　基本的IO编程过程（包括网络IO和文件IO）是，打开文件描述符（windows是handler，java是stream或channel），多路捕获（Multiplexe，即select和poll和epoll）IO可读写的状态，而后可以读写的文件描述符进行IO读写，由于IO设备速度和CPU内存比速度会慢，为了更好的利用CPU和内存，会开多线程，每个线程读写一个文件描述符。 　　但C10K问题，...
NIO详解（三）：IO多路复用模型之select、poll、epoll
Master-TJ的个人博客
04-02 2558
1. 前言 最近在研究基于Java的高性能异步非阻塞I/O框架Netty，因为最近做的RDMAChannel要用到其中的思想。Netty底层是通过大量的NIO实现的，通过分析底层NIO源码，发现NIO底层调用的是poll系统调用。所以本博客就来细谈select、poll、epoll系统调用。 2. NIO Selector底层源码分析 protected int doSelect(long tim...
Reactor模型与epoll模型的区别
工匠精神coding，终生学习
04-12 8190
select模式的特点： 1.单个进程监测的fd受限制，默认下是1024个文件描述符； 2.轮询式检查文件描述符集合中的每个fd可读可写状态，IO效率会随着描述符集合增大而降低； 3.可以采用一个父进程专门accept，父进程均衡的分配多个子进程分别处理一部分的链接，子进程采用select模型监测自己负责的fd的可读可写。
理解IO多路复用：select与epoll的深入剖析
本文档深入探讨了计算机网络编程中的I/O模型，特别是多路复用技术在Unix系统中的应用，如select和epoll。I/O模型是操作系统中处理并发网络通信的核心概念，它决定了进程在等待数据传输时的行为模式。 首先，理解...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值