Linux——多路IO

最新推荐文章于 2024-07-13 15:45:14 发布
最新推荐文章于 2024-07-13 15:45:14 发布
阅读量261 收藏 5
点赞数 10
文章标签： python 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_71703182/article/details/140378022
版权

IO多路复用

定义：单线程或单进程同时监测若IO干个文件描述符是否可以执行IO操作的能力

作用：
应用程序通常需要处理来自多条事件流中的事件，比如我现在用的电脑，需要同时处理键盘鼠标的输入、中断信号等等事件，再比如web服务器如nginx，需要同时处理来来自N个客户端的事件。

逻辑控制流在时间上的重叠叫做 并发

而CPU单核在同一时刻只能做一件事情，一种解决办法是对CPU进行时分复用(多个事件流将CPU切割成多个时间片，不同事件流的时间片交替进行)。在计算机系统中，我们用线程或者进程来表示一条执行流，通过不同的线程或进程在操作系统内部的调度，来做到对CPU处理的时分复用。这样多个事件流就可以并发进行，不需要一个等待另一个太久，在用户看起来他们似乎就是并行在做一样。

使用并发处理的成本：
线程/进程创建成本
CPU切换不同线程/进程成本 Context Switch
多线程的资源竞争

有没有一种可以在单线程/进程中处理多个事件流的方法呢？一种答案就是IO多路复用。

因此IO多路复用解决的本质问题是在用更少的资源完成更多的事。

IO模型

1、阻塞IO  
2、非阻塞IO  EAGAIN  忙等待 errno
3、信号驱动IO  SIGIO 用的相对少（了解）
4、并行模型 进程，线程
5, IO多路复用  select、poll、epoll

 



1、阻塞IO ===》最常用 默认设置

### 1. 阻塞IO

**定义**：
阻塞IO指的是需要内核IO操作彻底完成后才返回到用户空间执行用户程序的操作指令。在阻塞IO模型中，当用户进程发起一个IO请求（如读取文件或网络数据）时，进程会被阻塞，直到IO操作完成，内核将数据准备好并返回给用户进程。如果IO操作需要很长时间，那么用户进程将在这段时间内无法执行其他操作。

**特点**：
- 同步IO的一种形式。
- 用户进程在等待IO操作完成时处于阻塞状态，不能执行其他任务。
- 在Java中，默认创建的socket属于阻塞IO模型。


   IO：
   scanf()/printf() ====>默认的IO设备

   fgetc()/fputc()  ====》标准IO
   fgets()/fputs()  fp, stdin
   fread()/fwrite()
   
   read()/write()  ====》文件IO,pipe fifo

   recv()/send()   ====>tcp socket
   recfrom()/sendto() ===>udp socket

   scanf  fgetc  fgets fread read recv recvfrom  ==>阻塞等待

w

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
int main(int argc, char *argv[])
{
    int ret = mkfifo("myfifo",0666);    
    if(-1 == ret)
    {
        //如果是管道文件已存在错误，让程序继续运行
        if(EEXIST== errno)
        {

        }else 
        {
            perror("mkfifo");
            exit(1);
        }
    }
    //open 会阻塞，等到另一端读段打开，解除阻塞
    int fd = open("myfifo",O_WRONLY);
    if(-1 == fd)
    {
        perror("open");
        exit(1);
    }

    while(1)
    {
        char buf[256]="hello,fifo,test";
        write(fd,buf,strlen(buf));
        sleep(3);
    }
    close(fd);

    return 0;
}

r

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>

int main(int argc, char *argv[])
{
    int ret = mkfifo("myfifo",0666);    
    if(-1 == ret)
    {
        //如果是管道文件已存在错误，让程序继续运行
        if(EEXIST== errno)
        {
        
        }else 
        {
            perror("mkfifo");
            exit(1);
        }
    }

    int fd = open("myfifo",O_RDONLY);
    if(-1 == fd)
    {
        perror("open");
        exit(1);
    }
    while(1)
    {
        char buf[256]={0};
        read(fd,buf,sizeof(buf));
        printf("fifo %s\n",buf);
        
        bzero(buf,sizeof(buf));
        fgets(buf,sizeof(buf),stdin);
        printf("terminal:%s\n",buf);
    }
    close(fd);
    //remove("myfifo");

    return 0;
}

### 2. 非阻塞IO

**定义**：
非阻塞IO是程序在发送一个IO请求后无需等待其响应，期间可以执行其他任务，从而提高了程序运行的效率。如果IO操作不能立即完成，非阻塞IO会返回一个错误代码（如EWOULDBLOCK或EAGAIN），表示IO操作尚未完成。

**特点**：
- 用户进程发起IO请求后不会立即阻塞，而是可以立即返回继续执行其他任务。
- 如果IO操作尚未完成，会收到错误代码提示。

**EAGAIN**：
- EAGAIN是非阻塞IO中常见的错误代码之一，表示资源暂时不可用，需要稍后重试。
- 当用户进程在非阻塞模式下尝试读取或写入数据时，如果数据尚未准备好或缓冲区已满，就会收到EAGAIN错误。

**忙等待**：
- 忙等待通常与非阻塞IO结合使用，指的是在用户进程收到EAGAIN错误后，通过循环检查IO状态的方式等待IO操作完成。
- 这种方式会消耗CPU资源，因为进程需要不断检查IO状态，而不是被阻塞或进行其他有用的工作。



2.1 在程序开始阶段调整文件的打开方式为非阻塞：
===》open()===>fifo()的同步。
open("fifo",O_RDONLY|O_NONBLOCK);
====>read() 不再阻塞。

2.2 在程序执行阶段调整文件的执行方式为非阻塞：
===》fcntl() ===>动态调整文件的阻塞属性

#include <unistd.h>
#include <fcntl.h>
int fcntl(int fd, int cmd, ... /* arg */ );
功能：修改指定文件的属性信息。
参数：fd 要调整的文件描述符
  cmd 要调整的文件属性宏名称
  ... 可变长的属性值参数。
返回值：成功  不一定，看cmd
失败  -1；

eg：修改文件的非阻塞属性：
int flag ;
flag  = fcntl(fd,F_GETFL,0);  ///获取fd文件的默认属性到flag变量中。
flag  = flag | O_NONBLOCK;    ///将变量的值调整并添加非阻塞属性
fcntl(fd,F_SETFL,flag);       ///将新属性flag设置到fd对应的文件生效。

以上代码执行后的阻塞IO将变成非阻塞方式。

练习：编写fifo测试函数，完成fcntl控制的非阻塞方式读写。
  修改之前的tcp，udp程序用fcntl测试其非阻塞特性。

  如果是recv()/recvfrom（）===》参数flags == MSG_DONTWAIT
  如果是read()   ====>fcntl()

w

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
int main(int argc, char *argv[])
{
    int ret = mkfifo("myfifo",0666);    
    if(-1 == ret)
    {
        //如果是管道文件已存在错误，让程序继续运行
        if(EEXIST== errno)
        {

        }else 
        {
            perror("mkfifo");
            exit(1);
        }
    }
    //open 会阻塞，等到另一端读段打开，解除阻塞
    int fd = open("myfifo",O_WRONLY);
    if(-1 == fd)
    {
        perror("open");
        exit(1);
    }
    while(1)
    {
        char buf[256]="hello,fifo,test";
        write(fd,buf,strlen(buf));
        sleep(3);
    }
    close(fd);

    return 0;
}

r


#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>

int main(int argc, char *argv[])
{
    int ret = mkfifo("myfifo",0666);    
    if(-1 == ret)
    {
        //如果是管道文件已存在错误，让程序继续运行
        if(EEXIST== errno)
        {
        
        }else 
        {
            perror("mkfifo");
            exit(1);
        }
    }

    int fd = open("myfifo",O_RDONLY);
    if(-1 == fd)
    {
        perror("open");
        exit(1);
    }
    int flag = fcntl(fd,F_GETFL);
    flag = flag|O_NONBLOCK  ; 
    fcntl(fd,F_SETFL,flag);

    flag = fcntl(0,F_GETFL);
    fcntl(0,F_SETFL,flag|O_NONBLOCK);
    while(1)
    {
        char buf[256]={0};
        if(read(fd,buf,sizeof(buf))>0)
        {
            printf("fifo %s\n",buf);
        }
        bzero(buf,sizeof(buf));
        if(fgets(buf,sizeof(buf),stdin))
        {
            printf("terminal:%s\n",buf);
        }
    }
    close(fd);
    //remove("myfifo");

    return 0;
}

3.信号驱动IO（SIGIO）

**定义**：
信号驱动IO是指进程预先告知内核，当某个socket或文件描述符有事件发生时，内核使用信号（如SIGIO）通知相关进程。这样，进程就可以在需要时处理IO事件，而无需轮询或阻塞等待。

**特点**：
- 异步IO的一种形式。
- 减少了CPU资源的浪费，因为进程可以在等待IO事件时执行其他任务。
- 需要操作系统支持信号机制。

3.信号驱动io 
    文件描述符需要追加 O_ASYNC 标志。
    设备有io事件可以执行时，内核发送SIGIO信号。
    
        1.追加标志
        int flag ;
        flag  = fcntl(fd,F_GETFL,0);
        fcntl(fd,F_SETFL,flag | O_ASYNC);    
        2.设置信号接收者
        fcntl(fd,F_SETOWN,getpid());//常用设置
        3.对信号进行捕获
        signal(SIGIO,myhandle);//

w


#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
int main(int argc, char *argv[])
{
    int ret = mkfifo("myfifo",0666);    
    if(-1 == ret)
    {
        //如果是管道文件已存在错误，让程序继续运行
        if(EEXIST== errno)
        {

        }else 
        {
            perror("mkfifo");
            exit(1);
        }
    }
    //open 会阻塞，等到另一端读段打开，解除阻塞
    int fd = open("myfifo",O_WRONLY);
    if(-1 == fd)
    {
        perror("open");
        exit(1);
    }

    while(1)
    {
        char buf[256]="hello,fifo,test";
        write(fd,buf,strlen(buf));
        sleep(3);
    }
    close(fd);

    return 0;
}

r


#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
int main(int argc, char *argv[])
{
    int ret = mkfifo("myfifo",0666);    
    if(-1 == ret)
    {
        //如果是管道文件已存在错误，让程序继续运行
        if(EEXIST== errno)
        {

        }else 
        {
            perror("mkfifo");
            exit(1);
        }
    }
    //open 会阻塞，等到另一端读段打开，解除阻塞
    int fd = open("myfifo",O_WRONLY);
    if(-1 == fd)
    {
        perror("open");
        exit(1);
    }

    while(1)
    {
        char buf[256]="hello,fifo,test";
        write(fd,buf,strlen(buf));
        sleep(3);
    }
    close(fd);

    return 0;
}

4.并行模型：进程与线程

**进程**：
- 是操作系统进行资源分配和调度的一个独立单元。
- 每个进程都有自己独立的内存空间和系统资源。
- 进程是程序在计算机上的一次执行活动，是系统运行程序的基本单位。

**线程**：
- 是进程的一个实体，是CPU调度和分派的基本单位。
- 它是比进程更小的独立运行的单位，线程之间共享进程中的资源。
- 一个进程中可以拥有多个线程，这些线程共享进程的内存空间和系统资源。

**并行**：
- 指两个或多个事件在同一时刻发生（同时发生）。
- 在并行计算中，多个任务或操作可以在同一时间内执行，通常需要多核处理器或多台计算机的支持。

5.  IO多路复用

**定义**：
IO多路复用是一种在单个线程中管理多个输入/输出通道的技术。它允许一个线程同时监听多个IO事件（如网络连接、文件读写等），并在有数据可读或可写时进行相应的处理，而不需要为每个通道创建一个独立的线程。

**特点**：
- 提高了IO操作的效率，减少了线程切换和上下文切换的开销。
- 常见的IO多路复用机制包括select、poll和epoll（Linux特有）。

**总结**：
以上是对阻塞IO、非阻塞IO（包括EAGAIN和忙等待）、IO多路复用、信号驱动IO（SIGIO）以及并行模型中进程和线程的详细解释。这些概念在操作系统、网络编程和并发编程中扮演着重要角色，理解和掌握它们对于开发高效、可靠的应用程序至关重要。


    #include <sys/select.h>

    #include <sys/time.h>
    #include <sys/types.h>
    #include <unistd.h>

    int select(int nfds, fd_set *readfds, fd_set *writefds,
                fd_set *exceptfds,
                struct timeval *timeout);
    功能：完成指定描述符集合中有效描述符的动态检测。
          该函数具有阻塞等待功能，在函数执行完毕后
          目标测试集合中将只保留最后有数据的描述符。

    参数：nfds 描述符的上限值，一般是链接后描述符的最大值+1；
          readfds 只读描述符集
          writefds 只写描述符集
          exceptfds 异常描述符集
          以上三个参数都是 fd_set * 的描述符集合类型
          timeout  检测超时 如果是NULL表示一直检测不超时 。

    返回值：超时 0
            失败  -1
            成功 >0


        为了配合select函数执行，有如下宏函数：
        void FD_CLR(int fd, fd_set *set);
        功能：将指定的set集合中编号为fd的描述符号删除。

        int  FD_ISSET(int fd, fd_set *set);
        功能：判断值为fd的描述符是否在set集合中，
              如果在则返回真，否则返回假。

        void FD_SET(int fd, fd_set *set);
        功能：将指定的fd描述符，添加到set集合中。

        void FD_ZERO(fd_set *set);
        功能：将指定的set集合中所有描述符删除。


        select poll epoll的区别

1. select
int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);
void FD_CLR(int fd, fd_set *set);
int FD_ISSET(int fd, fd_set *set);
void FD_SET(int fd, fd_set *set);
void FD_ZERO(fd_set *set);

select的调用一般要注意几点：
① readfds等是指针结果参数，会被函数修改，所以一般会另外定义一个allread_fdset，保持全部要监听读的句柄，将它的拷贝传递给select函数，返回可读的句柄集合，类型fdset支持赋值运算符=；
② 要注意计算nfds，当新增监听句柄时比较容易修改，当减少监听句柄时较麻烦些，如果要精确修改需要遍历或者采用最大堆等数据结构维护这个句柄集，以方便的找到第二大的句柄，或者干脆在减少监听句柄时不管nfds；
③ timeout如果为NULL表示阻塞等，如果timeout指向的时间为0，表示非阻塞，否则表示select的超时时间；
④ select返回-1表示错误，返回0表示超时时间到没有监听到的事件发生，返回正数表示监听到的所有事件数（包括可读，可写，异常），通常在处理事件时 会利用这个返回值来提高效率，避免不必要的事件触发检查。（比如总共只有一个事件，已经在可读集合中处理了一个事件，则可写和异常就没必要再去遍历句柄集 判断是否发生事件了）；
⑤ Linux的实现中select返回时会将timeout修改为剩余时间，所以重复使用timeout需要注意。

select的缺点在于：
① 由于描述符集合set的限制，每个set最多只能监听FD_SETSIZE（在Linux上是1024）个句柄（不同机器可能不一样）；
② 返回的可读集合是个fdset类型，需要对所有的监听读句柄一一进行FD_ISSET的测试来判断是否可读；
③ nfds的存在就是为了解决select的效率问题（select遍历nfds个文件描述符，判断每个描述符是否是自己关心的，对关心的描述符判断是否发生事件）。但是解决不彻底，比如如果只监听0和1000两个句柄，select需要遍历1001个句柄来检查事件。


3. epoll
int epoll_create(int size)；
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event)；
int epoll_wait(int epfd, struct epoll_event * events, int maxevents, int timeout);

epoll 解决了select和poll的几个性能上的缺陷：①不限制监听的描述符个数（poll也是），只受进程打开描述符总数的限制；②监听性能不随着监听描述 符数的增加而增加，是O(1)的，不再是轮询描述符来探测事件，而是由描述符主动上报事件；③使用共享内存的方式，不在用户和内核之间反复传递监听的描述 符信息；④返回参数中就是触发事件的列表，不用再遍历输入事件表查询各个事件是否被触发。
epoll显著提高性能的前提是：监听大量描述符，并且每次触发事件的描述符文件非常少。
epoll的另外区别是：①epoll创建了描述符，记得close；②支持水平触发和边沿触发。
 

w

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
int main(int argc, char *argv[])
{
    int ret = mkfifo("myfifo",0666);    
    if(-1 == ret)
    {
        //如果是管道文件已存在错误，让程序继续运行
        if(EEXIST== errno)
        {

        }else 
        {
            perror("mkfifo");
            exit(1);
        }
    }
    //open 会阻塞，等到另一端读段打开，解除阻塞
    int fd = open("myfifo",O_WRONLY);
    if(-1 == fd)
    {
        perror("open");
        exit(1);
    }

    while(1)
    {
        char buf[256]="hello,fifo,test";
        write(fd,buf,strlen(buf));
        sleep(3);
    }
    close(fd);

    return 0;
}

r

  int ret = mkfifo("myfifo",0666);    
    if(-1 == ret)
    {
        //如果是管道文件已存在错误，让程序继续运行
        if(EEXIST== errno)
        {
        
        }else 
        {
            perror("mkfifo");
            exit(1);
        }
    }

    int fd = open("myfifo",O_RDONLY);
    if(-1 == fd)
    {
        perror("open");
        exit(1);
    }
    //1 create set 
    fd_set rd_set,tmp_set;
    //2 add fd 
    FD_ZERO(&rd_set);
    FD_ZERO(&tmp_set);
    FD_SET(fd,&tmp_set);
    FD_SET(0,&tmp_set);

    while(1)
    {
        //4 clean flag
        rd_set = tmp_set;
        //3 wait event 
        select(fd+1,&rd_set,NULL,NULL,NULL);

        char buf[256]={0};
        if(FD_ISSET(fd,&rd_set))
        {
            read(fd,buf,sizeof(buf));
            printf("fifo %s\n",buf);
        }
        if(FD_ISSET(0,&rd_set))
        {
            bzero(buf,sizeof(buf));
            fgets(buf,sizeof(buf),stdin);
            printf("terminal:%s\n",buf);
        }
    }
    close(fd);

pin️‍灼灼灼灼
关注
  • 10
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
基于VS2019 C++的跨平台（Linux）开发的项目——360 度智能行车辅助系统
05-29
基于 Socket 网络通讯技术，使用Qt5进行GUI编程，结合OpenCV图像处理，采用Sqlite3数据库，实现的 360 度智能...项目核心技术点 ：服务器分离、共享内存设计、线程池、Socket网络编程、进程间通信、epoll多路IO复用等。
Java IO复用_动力节点Java学院整理
08-30
在Linux上，多路复用技术如select、poll和epoll提供了这样的能力。这些技术可以让单个线程监视多个连接，当某个连接有数据可读或可写时，操作系统会通知线程，而不是让线程持续检查。 其中，epoll是Linux 2.6内核...
Linux网络编程—— IO多路复用
weixin_43412762的博客
03-03 1697
 I/O 多路复用 使得程序能 同时监听 多个文件描述符，能够提高程序的性能，Linux 下实现 I/O 多路复用 的 系统调用主要有 select、poll 和 epoll。
LInux——五种IO模型
qq_44824574的博客
03-30 1172
Linux中的IO简述 IO主要分为以下的三种： 内存IO 网络IO 磁盘IO 通常我们所说的IO是后两者，Linux中无法直接操作IO设备，必须通过系统调用请求kernal来协助完成IO的动作，内存会为每一个IO设备维护一个缓冲区。 IO操作会涉及两个对象： 调用这个IO的进程（或线程）； 系统内核的kernal 五种模型介绍 1、阻塞IO 最简单的一种IO模型，简单理解就是死等，即进程或线程一直等待某个条件，不满足就会一直等待。 2、非阻塞IO 应用进程与内核交互，不断轮询，不停地去问内核数据是
Linux——IO复用
weixin_52152227的博客
07-07 527
I/O多路复用技术 I/O多路转接模型
Linux网络——高级IO
qq_63943454的博客
12-11 1967
select ， poll ，epoll 实现多路转接方案
Linux——高级IO
m0_64607843的博客
07-03 958
本章介绍了5种IO模型，并且实现了非阻塞式IO，下一篇我们就重点介绍一下多路转接。
（牛客网C++课程）Linux 高并发Web服务器项目实战（带定时检测代码）
02-24
2. 用 epoll 事件检测技术实现 IO 多路复用，提高运行效率； 3. 采用模拟 Proacto r的事件处理模式，利用线程池实现多线程机制，实现高并发通信，减少频繁创建和销毁线程带来的开销；（信号和互斥锁） 4. 主进程负责...
CVM网络类库——源代码
08-15
CVM是一个基于Linux的小型网络类库，她主要提供多路分离复用、线程池、内存管理和数据访问功能。 多路分离复用：是对Epoll和IO的使用封装，使得使用者可以完全与Epoll的细节隔开，专心于IO的处理 线程池：提供一种...
cv2读取和保存图片
m0_53291740的博客
07-12 110
cv2.imwrite('b\\img1.png',img)#b存在就可以保存进去。如果b存在，c不存在，程序不会报错，也不会保存图片。如果目录b不存在就会存到当前文件夹。
面试题 21：解释 Python 中的 help() 函数和 dir() 函数？
专注于全栈开发领域
07-10 748
在Python中，help()和dir()是两个非常有用的内置函数，它们可以帮助开发者更好地了解Python对象和模块。
聊聊如何在内网下构建大模型微调环境
python1234567_的博客
07-12 675
LlamaFactory新版更新后，还是比较方便，只是说llamafactory-cli命令的确是有点蒙，踩个坑就好了。对于LlamaFactory微调来说，本身不难，毕竟都是配置；主要是在内网环境下的依赖包拉取安装是真麻烦，但其实也还好。走一遍的话，还是可以学到很多的。​。
leetcode--验证二叉搜索树
liulanba的博客
07-09 658
给你一个二叉树的根节点 root ，判断其是否是一个有效的二叉搜索树。有效 二叉搜索树定义如下：节点的左子树只包含 小于 当前节点的数。节点的右子树只包含 大于 当前节点的数。所有左子树和右子树自身必须也是二叉搜索树。示例 1：输入：root = [2,1,3]输出：true示例 2：输入：root = [5,1,4,null,null,3,6]输出：false解释：根节点的值是 5 ，但是右子节点的值是 4。提示：树中节点数目范围在[1, 104] 内。
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
小明的Java问道之路
07-08 2378
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
一键安装ros及出现问题的解决方案
m0_58173801的博客
07-10 558
catkin_make时出现报错如下。
【python学习】闭包的定义与特点，以及一些常用场景的使用
m0_49243785的博客
07-11 1015
闭包是一个函数，闭包让你可以在一个内层函数中访问其外层函数的作用域，可以使用闭包进行模块化代码和封装代码的操作，从而提高效率。
Java进阶篇之Fork/Join 框架：并行处理的艺术
小码农的博客
07-09 680
在多核时代，如何有效利用多核处理器的并行计算能力成为了软件开发中的重要议题。Java 7引入的Fork/Join框架正是为此目的而生，它提供了一套高度优化的并行任务分解和合并机制，极大地简化了并行编程的复杂度，同时提升了应用程序的性能。本文将全面剖析Fork/Join框架的原理、使用方法及最佳实践。Fork/Join框架的核心在于将一个大任务分解（Fork）成多个较小的子任务，并行执行这些子任务，然后将子任务的结果合并（Join）起来形成最终结果。
编程学单词：delta(希腊字母Δ/δ)，差值表示
m0_57158496的博客
07-11 1093
结语：代码编写中，用“通用”字符命名相应变量，是一个不错的好习惯。其一，不用注释，望文生义，简单明了；其二，代码书写形式风格“标准”统一，方便维护和流转。说明：今天我在堆叠代码时发现有delta样子的单词存在，修习之，对代码书写大有裨益。从今以后，我遇到类似的单词，都将在学习笔记中标识、分享。😋回页目录。
AIGC专栏13——ComfyUI 插件编写细节解析-以EasyAnimateV3为例
最新发布
Bubbliiiing的学习小课堂
07-13 1061
最近在给EasyAnimateV3写ComfyUI的工作流，以方便别人测试。学习了ComfyUI的基本操作，也看了一下别人是怎么写的，自己也折腾了一下。在人工智能艺术创作的领域里，Stable Diffusion 凭借其开放源代码的特性，吸引了众多开发者与艺术家的目光，并且因为强大的社区支持而展现出强大的影响力。Stable Diffusion 的两大主流创作平台分别是 Stable Diffusion WebUI 与 ComfyUI。
linux下的io多路复用
04-08
在Linux下，IO多路复用是一种高效的IO处理机制，它允许一个进程同时监视多个文件描述符的可读、可写或异常事件。通过使用IO多路复用，可以避免使用阻塞IO或者多线程/多进程的方式来处理并发IO操作，提高系统的性能和资源利用率。 Linux下常用的IO多路复用机制有以下三种： 1. select：select函数是最早引入的IO多路复用机制，它通过一个位图来表示需要监视的文件描述符集合，并通过轮询的方式检查每个文件描述符的状态变化。select函数的缺点是，每次调用时需要将所有待监视的文件描述符集合从用户态拷贝到内核态，导致性能较低。 2. poll：poll函数是对select函数的改进，它使用链表来表示需要监视的文件描述符集合，并通过轮询的方式检查每个文件描述符的状态变化。相比select函数，poll函数不需要将文件描述符集合从用户态拷贝到内核态，性能有所提升。 3. epoll：epoll是Linux特有的IO多路复用机制，它通过使用事件驱动的方式来处理IO事件。epoll使用一个事件表来存储需要监视的文件描述符和对应的事件类型，并通过回调函数来处理事件。相比select和poll，epoll具有更高的性能和扩展性。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值