Linux下的五种I/O模型

最新推荐文章于 2022-03-27 21:13:13 发布
最新推荐文章于 2022-03-27 21:13:13 发布
阅读量382 收藏
点赞数
分类专栏： linux 文章标签： select poll io
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LP9127/article/details/74004508
版权
一、五种I/O模型

1、阻塞I/O模型
应用程序调用一个I/O函数，导致应用程序阻塞，等待数据，如果数据没有准备好，则一直阻塞，直到数据准备好，将数据从内核空间拷贝到用户空间，I/O函数成功返回。
2、非阻塞I/O模型
将套接口设置为非阻塞形式就是告诉内核，当所请求的I/O函数还没有准备好时，直接返回错误，而不让进程进入睡眠状态，此后，I/O函数不断地测试数据有没有准备好，如果数据没有准备好，则不断进行测试，直到数据准备好为止。在测试期间会浪费CPU的资源。
3、I/O复用模型
I/O复用模型会用到select函数、poll函数或者poll函数。该模型也会阻塞等待I/O函数，但是与阻塞I/O模型不同的是，该模型可以同时阻塞多个I/O，并且可以同时对多个读操作和写操作的I/O函数进行检测，直到有数据可读或者可写时，才真正调用I/O函数。
4、信号驱动模型
首先允许套接口进行信号驱动I/O，并安装一个信号处理函数，进行继续运行并不阻塞，当数据准备好时，进程会收到一个SIGIO信号，可以信号处理函数中调用I/O操作函数处理数据。
5、异步I/O模型
调用aio_read函数，告诉内核描述字，缓冲区指针，缓冲区大小，文件偏移以及通知的方式，然后立即返回，直到数据准备好之后，再通知应用程序。

二、同步I/O与异步I/O

1、同步
所谓同步就是调用者发出一个调用，在该调用返回之前，调用者一直进行等待，直到调用成功为止，调用者返回并带返回值。
2、异步
调用者发出一个调用请求，然后直接返回，此次返回没有返回值，然后被调用者通过状态来通知调用者，或者通过回掉函数来处理这个调用。

三、阻塞与非阻塞

阻塞与非阻塞指的是应用程序在等待调用结果时的状态
1、阻塞等待
在调用结果返回之前线程会挂起，直到得到调用结果之后才会返回。
2、非阻塞等待
在调用结果返回之前不会一直等待，也就是应用程序不会阻塞当前线程。
目前的阻塞和非阻塞是针对同步机制来说的。

四、高级I/O

非阻塞I/O、记录锁、系统V流机制、I/O多路转接、readv函数和writev函数、存储映射I/O都属于高级I/O。

五、I/O多路转接

什么叫多路转接？
对于多个非阻塞的I/O，如何知道该I/O是否已经准备好读数据或者写数据？
方法一：采用read函数和write函数进行轮询式的检测，知道有数据准备好被读写为止，但是这种方法十分浪费CPU的资源；
方法二：采用I/O多路转接（I/O复用技术）：先构造一张列表，该列表中存储的是文件描述符。然后调用一个函数（select/poll/epoll）进行等待，当文件描述符列表中的一个或者多个文件描述符准备好之后，该函数就进行返回，函数返回时告诉当前进程哪些文件描述符已经准备好了。

六、I/O多路转接之select函数

1、函数原型
int select(int nfds, fd_set *readfds, fd_set *writefds,
fd_set *exceptfds, struct timeval *timeout);

2、需要包含的头文件：
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
3、参数类型说明：
fd_set：表示文件描述符集合
struct timeval：是一个用于描述监视时间的结构体，如果在规定的时间之内，需要检测的文件描述符没有事件发生，则返回0值。
该结构体如下所示：
这里写图片描述
4、参数说明：
nfds：需要监视的最大文件描述符值加一
readfds：需要检测的可读文件描述符集合
writefds：需要检测的可写文件描述符集合
exceptfds：需要检测的异常文件描述符集合
timeout：函数的等待时间
5、用四种宏处理三种描述词组
（1）FD_CLR(int fd,fd_set* set)；用来清除描述词组set中相关fd 的位。
（2）FD_ISSET(int fd,fd_set *set)；用来测试描述词组set中相关fd 的位是否为真。
（3）FD_SET（int fd,fd_set*set）；用来设置描述词组set中相关fd的位 。
（4）FD_ZERO（fd_set *set）；用来清除描述词组set的全部位 。
6、参数timeout的取值
（1）NULL：表示让函数select一直进行阻塞，直到某个文件描述符上的事件就绪。
（2）0：表示不等待文件描述符上的事件是否就绪，直接返回。
（3）取某一特定值x：表示在x时间内若还没有文件描述符上的事件就绪，则超时返回。
7、函数的返回值
（1）执行成功：则返回已经就绪的文件描述符的个数。
（2）返回0：意思为超时返回，即在指定时间内没有文件描述符的对应的事件就绪。
（3）返回-1：出错返回，出现错误的可能原因有：
错误原因存于errno，此时参数readfds，writefds，exceptfds和 timeout的值变成不可预测。错误值可能为： EBADF 文件描述词为无效的或该文件已关闭。
EINTR 此调用被信号所中断。
EINVAL 参数n 为负值。
ENOMEM 核心内存不足。
8、用select函数实现网络服务器
代码如下：

#include <stdio.h>
#include <unistd.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/select.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <string.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <fcntl.h>

static void usage(const char* proc)
{
    printf("%s [local_ip] [local_port]\n",proc);
}

int CreatSock(const char* _ip,int _port)
{
    int Sock=socket(AF_INET,SOCK_STREAM,0);
    if(Sock<0)
    {
        perror("socket");
        exit(2);
    }

    struct sockaddr_in local;
    local.sin_family=AF_INET;
    local.sin_port=htons(_port);
    local.sin_addr.s_addr=inet_addr(_ip);

    if(bind(Sock,(struct sockaddr*)&local,sizeof(local))<0)
    {
        perror("bind");
        exit(3);
    }

    if(listen(Sock,5)<0)
    {
        perror("listen");
        exit(4);
    }
    return Sock;
}

int main(int argc,char* argv[])
{
    if(argc!=3)
    {
        usage(argv[0]);
        return 1;
    }

    char fds[1024];
    int listensock=CreatSock(argv[1],atoi(argv[2]));
    int nums=sizeof(fds)/sizeof(fds[0]);
    int maxfd=-1;
    int i=1;
    for(;i<nums;i++)
    {
        fds[i]=-1;
    }

    fds[0]=listensock;

    umask(0);
    int open_fd=open("./sever_log",O_CREAT | O_RDWR,0664);
    if(open_fd<0)
    {
        perror("open");
        exit(10);
    }
    close(1);

    int ret=dup2(open_fd,1);

    char buf[1024];
    while(1)
    {
        struct timeval timeout={5,0};
        fd_set set;
        FD_ZERO(&set);
        maxfd=-1;

        for(i=0;i<nums;i++)
        {
            if(fds[i]>0)
            {
                FD_SET(fds[i],&set);
                if(maxfd<fds[i])
                {
                    maxfd=fds[i];
                }
            }
        }
        switch(select(maxfd+1,&set,NULL,NULL,NULL))
        {
            case 0:
                printf("timeout...\n");
                break;
            case -1:
                perror("select\n");
                break;
            default:
            {
                int i=0;
                for(;i<nums;i++)
                {
                    if(fds[i]<0)
                        continue;

                if(i==0 && FD_ISSET(listensock,&set))
                {
                    struct sockaddr_in client;
                    socklen_t len=sizeof(client);
                    int new_fd=accept(listensock,(struct sockaddr*)&client,&len);
                    if(new_fd<0)
                    {
                        perror("accept\n");
                        exit(5);
                    }

                    printf("get a client:[%s:%d]\n",inet_ntoa(client.sin_addr),ntohs(client.sin_port));

                    int j=1;
                    for(;j<nums;j++)
                    {
                        if(fds[j]==-1)
                        {
                            break;
                        }
                    }

                    if(j==nums)
                    {
                        printf("set is full\n");
                        close(new_fd);
                    }

                    else
                    {
                        fds[j]=new_fd;
                    }
                }
                else if(i>0 && FD_ISSET(fds[i],&set))
                {
                    ssize_t s=read(fds[i],buf,sizeof(buf));
                    if(s>0)
                    {
                        buf[s]=0;
                        printf("client say:%s\n",buf);
                        fflush(stdout);
                        write(fds[i],buf,strlen(buf));
                    }
                    else if(s==0)
                    {
                        printf("client quit\n");
                        fflush(stdout);
                        close(fds[i]);
                        fds[i]=-1;
                    }
                    else
                    {
                        perror("read\n");
                    }

                }
                else
                {
                    ;
                }
                }
            }
                break;
        }
    }
    close(open_fd);
    return 0;
}

通过对该函数的实现，可以更加深入地了解select模型
（1）可监控的文件描述符个数取决于sizeof(fd_set)：例如sizeof(fd_set)=512，则最多可监控的文件描述符个数为(512*8)，因为一个文件描述符占据一个比特位。
（2）必须使用一个全局数组来保存加入到select监控集中的文件描述符，该全局数组有两个作用：
a.用于select函数返回之后，全局数组作为源数据和fd_set进行判断；
b.由于select函数每次返回之后就会将fd_set中之前加入的但是并没有发生事件的文件描述符清空，因此在重新调用select函数之前都要重新从全局数组中取得文件描述符加入fd_set中，并且扫描最大的文件描述符值加1，作为select函数的第一个参数。
c.select模型必须在select函数调用之前循环全局数组：用于往fd_set中加文件描述符，并取得最大的文件描述符值；
也必须在select函数返回之后循环全局数组：用于判断fd_set中的文件描述符是否有效。
该函数中使用了网络输出重定向dup函数，将本应该输出到显示屏上的内容输出到了文件中。

下面是客户端的代码：

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <unistd.h>
#include <string.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <sys/stat.h>
#include <fcntl.h>

static void usage(const char* proc)
{
    printf("usage:%s [remote_ip] [remote_port]\n",proc);
}


int main(int argc,char* argv[])
{
    if(argc!=3)
    {
        usage(argv[0]);
        exit(1);
    }

    int sock=socket(AF_INET,SOCK_STREAM,0);
    if(sock<0)
    {
        perror("socket");
        exit(2);
    }

    struct sockaddr_in remote;
    remote.sin_family=AF_INET;
    remote.sin_port=htons(atoi(argv[2]));
    remote.sin_addr.s_addr=inet_addr(argv[1]);

    if(connect(sock,(struct sockaddr*)&remote,sizeof(remote))<0)
    {
        perror("connect");
        exit(3);
    }

    umask(0);
    int fd=open("./client_log",O_CREAT | O_RDWR,0664);
    if(fd<0)
    {
        perror("open");
        exit(4);
    }
    close(1);
    int new_fd=dup2(fd,1);

    char buf[1024];
    while(1)
    {
        printf("please enter:");
        memset(buf,'\0',sizeof(buf));
        fgets(buf,sizeof(buf),stdin);
        if(strncmp("quit",buf,4)==0)
        {
            printf("quit\n");
            printf("client is quit!\n");
            break;
        }
        printf("%s\n",buf);
        fflush(stdout);

        write(sock,buf,strlen(buf));
        ssize_t s=read(sock,buf,sizeof(buf)-1);
        if(recv>0)
        {
            buf[s]=0;
            printf("sever echo:%s\n",buf);
        }
    }
    close(fd);
    return 0;
}

该程序中依然使用了dup函数进行了网络输出重定向。

七、I/O多路转接之poll函数

1、函数原型
int poll(struct pollfd *fds, nfds_t nfds, int timeout);
2、需要包含的头文件
#include <poll.h>
3、参数说明
（1）pollfd是一个结构体，该结构体的结构成员如下：

　struct pollfd{
　　int fd; //poll监控的文件描述符
　　short events; //请求的事件
（fd上等待的事件）
　　short revents; //返回的事件
（fd上实际发生的事件）
　　};
第一个参数fds是一个数组，理论上poll所能等待的文件描述符没有上限，一次可以传入一个数组，这与select函数使用三个位图来描述三个文件描述符集的方式不同，同时pollfd结构体包含了要等待的事件和实际返回的事件，这点也不同于select函数，不用“参数-值”的形式进行传递。

poll所能处理的文件描述符上的事件：
POLLIN：当前有数据可读；
POLLPRI：读取优先级高的数据，即优先处理紧急指针所指向的数据；
POLLOUT：当前写入数据；

（2）　第二个参数表示poll函数监视的文件描述符的个数。
（3）第三个参数timeout和select函数中的timeout的作用是相同的，timeout可以取三个值，每个值代表不同的含义：
a.-1：表示如果监视的文件描述符没有事件发生，则一直进行阻塞等待，直到有事件发生为止；
b.0：表示不等待fd上所请求的事件，直接返回；
c.某一特定值x：表示在一段特定时间x内监控的文件描述符上所等待的事件没有发生，则超时返回。
4、poll函数与select函数的联系
（1）poll是select的优化版本，主要体现在两个方面：
a.poll所能监控的文件描述符理论上是没有上限的，由于poll每次传入一个数组；
b.poll将输入参数（所监控的文件描述符上所等待的事件）和输出参数（所监控的文件描述符上实际发生的事件）进行分离，因此在使用poll函数之前不需要重新传入文件描述符。
（2）poll和select一样，都需要在返回之后对poll或者select轮询来获取准备就绪的文件描述符。
5、函数返回值也同select
（1）执行成功：则返回已经就绪的文件描述符的个数。
（2）返回0：意思为超时返回，即在指定时间内没有文件描述符的对应的事件就绪。
（3）返回-1：出错返回
6、用poll实现网络服务器
代码如下：

#include <stdio.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <poll.h>

#define MAXBUFSIZE 1024
#define MAXFD 1024

static void usage(const char* proc)
{
    printf("Usage:%s [local_ip] [local_port]\n",proc);
}

int CreatSock(char* _ip,int _port)
{
    int sock=socket(AF_INET,SOCK_STREAM,0);
    if(sock<0)
    {
        perror("socket");
        exit(2);
    }

    struct sockaddr_in local;
    local.sin_family=AF_INET;
    local.sin_port=htons(_port);
    local.sin_addr.s_addr=inet_addr(_ip);

    if(bind(sock,(struct sockaddr*)&local,sizeof(local))<0)
    {
        perror("bind");
        exit(3);
    }

    if(listen(sock,5)<0)
    {
        perror("listen");
        exit(4);
    }
    return sock;
}
int main(int argc,char* argv[])
{
    if(argc!=3)
    {
        usage(argv[0]);
        exit(1);
    }

    int listenSock=CreatSock(argv[1],atoi(argv[2]));

    char buf[MAXBUFSIZE];
    struct pollfd fds[MAXFD];
    int i=0;
    int maxfd=0;
    for(;i<MAXFD;i++)
    {
        fds[i].fd=-1;
        fds[i].events=POLLIN|POLLOUT;
    }

    fds[0].fd=listenSock;
    while(1)
    {
        maxfd=0;
        for(i=0;i<MAXFD;i++)
        {
            if(fds[i].events&(POLLIN|POLLOUT))
            {
                maxfd=i;
            }
        }
        switch(poll(fds,maxfd+1,-1))
        {
            case 0:
                printf("timeout...\n");
                break;
            case -1:
                perror("poll");
                exit(5);
                break;
            default:
                {
                    int i=0;
                    for(;i<MAXFD;i++)
                    {
                        if(fds[i].fd<0)
                            continue;

                        if(i==0 && (fds[i].fd & POLLIN))
                        {
                            struct sockaddr_in client;
                            socklen_t len=sizeof(client);

                            int new_fd=accept(listenSock,(struct sockaddr*)&client,&len);
                            if(new_fd<0)
                            {
                                perror("accept");
                                exit(6);
                            }

                          printf("get a client:[%s:%d]\n",inet_ntoa(client.sin_addr),ntohs(client.sin_port));

                          int j=1;
                          for(;j<MAXFD;j++)
                          {
                              if(fds[j].fd==-1)
                              {
                                  break;
                              }
                          }

                          if(j==MAXFD)
                          {
                              printf("fds is full\n");
                              close(new_fd);
                          }
                          else
                          {
                              fds[j].fd=new_fd;
                              fds[j].events=POLLIN|POLLOUT;
                          }
                        }

                        else if(i!=0 && (fds[i].fd!=-1))
                        {
                            while(1)
                            {
                             ssize_t s=read(fds[i].fd,buf,sizeof(buf));
                             if(s>0)
                             {
                                buf[s]=0;
                                printf("client say:%s\n",buf);
                                fflush(stdout);
                                write(fds[i].fd,buf,strlen(buf));
                             }
                            else if(s==0)
                             {
                                printf("client is quit!\n");
                                fflush(stdout);
                                close(fds[i].fd);
                                fds[i].fd=-1;
                                break;
                             }
                            else
                             {
                                perror("read");
                                exit(7);
                             }
                            }
                        }
                        else
                        {}
                    }
                }

                break;
        }
    }
    close(listenSock);
    return 0;
}

下面是客户端代码：

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <unistd.h>
#include <string.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <sys/stat.h>
#include <fcntl.h>

static void usage(const char* _proc)
{
    printf("usage:%s [sever_ip] [sever_port]\n",_proc);
}

int main(int argc,char* argv[])
{
    if(argc!=3)
    {
        usage(argv[0]);
        exit(1);
    }

    int sock=socket(AF_INET,SOCK_STREAM,0);
    if(sock<0)
    {
        perror("socket");
        exit(2);
    }


    struct sockaddr_in remote;
    remote.sin_family=AF_INET;
    remote.sin_port=htons(atoi(argv[2]));
    remote.sin_addr.s_addr=inet_addr(argv[1]);

    int ret=connect(sock,(struct sockaddr*)&remote,sizeof(remote));
    if(ret<0)
    {
        perror("connect");
        exit(3);
    }

    umask(0);
    int fd=open("./pc_log",O_CREAT|O_RDWR,0664);
    if(fd<0)
    {
        perror("open");
        exit(4);
    }
    close(1);
    int new_fd=dup2(fd,1);

    char buf[1024];
    while(1)
    {
        printf("please enter:");
        memset(buf,'\0',sizeof(buf));
        fgets(buf,sizeof(buf),stdin);
        if(strncmp("quit",buf,4)==0)
        {
            printf("client quit!\n");
            break;
        }
        printf("%s\n",buf);
        fflush(stdout);

        write(sock,buf,strlen(buf));
        ssize_t _s=read(sock,buf,sizeof(buf)-1);
        {
            if(_s>0)
            {
                buf[_s]=0;
                printf("sever echo:%s\n",buf);
            }
        }
    }

    close(fd);
    return 0;
}

说明：客户端的输入全部重定向在文件pc_log中。

LP9127
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
I/O模型
希望我的博客，能帮上你解决学习中工作中所遇到的问题
02-13 469
1 概念说明 在进行解释之前，首先要说明几个概念： 用户空间和内核空间 进程切换 进程的阻塞 文件描述符 缓存 IO 1.1 用户空间与内核空间 现在操作系统都是采用虚拟存储器，那么对32位操作系统而言，它的寻址空间（虚拟存储空间）为4G（2的32次方）。操作系统的核心是内核，独立于普通的应用程序，可以访问受保护的内存空间，也有访问底层硬件设备的所有权限。为了保证用户进程不能直接操作内核（kernel），保证内核的安全，操作系统将虚拟空间划分为两部分，一部分为内核空间，一部分为用户空间。针对linux操作系
深入理解linux五种IO模型
m0_74282605的博客
01-07 271
当外围设备完成用户请求的操作后，会向CPU发出相应的中断信号，这时CPU会暂停执行下一条即将要执行的指令转而去执行与中断信号对应的处理程序，如果先前执行的指令是用户态下的程序，那么这个转换的过程自然也就发生了由用户态到内核态的切换。在Linux的缓存IO 机制中，操作系统会将 IO 的数据缓存在文件系统的页缓存（ page cache ）中，也就是说，数据会先被拷贝到操作系统内核的缓冲区中，然后才会从操作系统内核的缓冲区拷贝到应用程序的地址空间。数据准备好后，从内核拷贝到用户空间，IO函数返回成功指示。
Linux的五个I/O模型
QtHalcon
09-23 4617
前面的 fcntl()函数解决了文件的共享问题， 接下来该处理 I/O 复用的情况了。 总的来说， I/O 处理的模型有 5 种。  1.阻塞 I/O 模型： 在这种模型下， 若所调用的 I/O 函数没有完成相关的功能， 则会使进程挂起， 直到相关数据到达才会返回。 如常见对管道设备、 终端设备和网络设备进行读写时经常会出现这种情况。 2.非阻塞 I/O 模型： 在这种模型下， ...
服务器基础:聊聊Linux中的5种I/O模型
临江之阁
10-10 4364
1 概念说明在进行解释之前，首先要说明几个概念：用户空间和内核空间进程切换进程的阻塞文件描述符缓存 IO1.1 用户空间与内核空间现在操作系统都是采用虚拟存储器，那么对32位操作系统而言，它的寻址空间（虚拟存储空间）为4G（2的32次方）。操作系统的核心是内核，独立于普通的应用程序，可以访问受保护的内存空间，也有访问底层硬件设备的所有权限。为了保证用户进程不能直接操作内核（kernel），保证内核的
浅谈Linux 网络 I/O 模型简介（图文）
09-15
主要介绍了浅谈Linux 网络 I/O 模型简介（图文），小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
5种异步I/O模型
11-13
Windows操作系统提供了选择（Select）、异步选择 （WSAAsyncSelect）、事件选择（WSAEventSelect）、重叠I/O（Overlapped I/O）和完成端口（Completion Port)共五种I/O模型。每一种模型均适用于一种特定的应用场景。...
Linux下套接字I_O复用模型介绍.pdf
09-06
Linux下套接字I_O复用模型介绍.pdf
通信模型详解，linux下通信EPOLL详解
04-08
Windows完成端口介绍 Linux EPOLL介绍 同步I/O与异步I/O 说起完成端口，它的实现机制其实是重叠I/O实现异步I/O操作，下面就结合同步I/O来解释下什么是异步I/O
linux五种IO模型
bobozai86的博客
03-27 4103
为了更好的理解五种IO模型，我们先来说一下几个概念：同步，异步，阻塞和非阻塞。 同步和异步 　　这两个概念与消息的通知机制有关。 同步 　　所谓同步，就是在发出一个功能调用时，在没有得到结果之前，该调用就不返回。比如，调用readfrom系统调用时，必须等待IO操作完成才返回。 异步 　　异步的概念和同步相对。当一个异步过程调用发出后，调用者不能立刻得到结果。实际处理这个调用的部件在完成后，通过状态、通知和回调来通知调用者。比如：调用aio_read系统调用时，不必等IO操作完成就直接返回，调用
【Linux基础】Linux的5种IO模型详解
白夜行
07-04 9170
引入为了更好的理解5种IO模型的区别，在介绍IO模型之前，我先介绍几个概念1.进程的切换（1）定义为了控制进程的执行，内核必须有能力挂起正在CPU上运行的进程，并恢复以前挂起的某个进程的执行。即从用户态（较低的3G字节）切换到内核态（最高的1G字节），非常消耗系统资源。（2）过程 保存处理机上下文，包括程序计数器和其他寄存器。 更新PCB信息。 把进程的PCB移入相应的队列，如就绪、在某事件阻塞等队
Linux 五种IO模型详细图解
男儿当自强
09-14 380
一、IO 简述 IO (Input/Output，输入/输出)即数据的读取（接收）或写入（发送）操作，通常用户进程中的一个完整IO分为两阶段：用户进程空间<–>内核空间、内核空间<–>设备空间（磁盘、网络等）。 IO有内存IO、网络IO和磁盘IO三种，通常我们说的IO指的是后两者。 LINUX中进程无法直接操作I/O设备，其必须通过系统调用请求kernel来协助完成I/O动作；内核会为每个I/O设备维护一个缓冲区。 对于一个输入（读取到内存）操作来说，进程IO系统调用后，
linux 5中io模型
qq_38847853的博客
06-25 858
1.5种io模型阻塞IO（bloking IO）非阻塞IO（non-blocking IO）多路复用IO（multiplexing IO）信号驱动式IO（signal-driven IO）异步IO（asynchronous IO）一个输入操作通常包括两个阶段：1.等待数据准备好2.从内核向进程复制数据缓存IO（又被称为标准io）：IO的数据缓存在文件系统的页缓存（page cache）中（先拷贝到...
Linux下5种IO模型
小识的博客
06-23 678
类型 本文总结自极客时间《深入拆解Tomcat和Jetty》 UNIX系统下的IO模型有5种 同步阻塞IO 同步非阻塞IO IO多路复用 信号驱动IO 异步IO 当用户线程发起I/O操作后，会经历2个步骤 1.用户线程等待内核将数据从网卡拷贝到内核空间 2.内核将数据从内核空间拷贝到用户空间 各种I/O模型的区别就是：他们实现这2个步骤的方式是不一样的 同步阻塞IO 同步阻塞IO：用户线程发起re...
Linux下的I/O模型
月饼大叔的博客
08-14 138
用户空间和内核空间：操作系统采用虚拟存储器，对于32位系统而言，寻址空间为4G。操作系统的核心是内核，独立于普通的应用程序，可以访问受保护的内存空间，也有访问底层硬件设备的所有权限。为了保证用户不能直接操作内核，保证内核的安全，操作系统将虚拟空间划分为两部分，一部分为内核空间，一部分为用户空间。针对Linux操作系统而言，将最高的1G分给内核，成为内核空间，较低的3G给应用程序，成为用户空间。 ...
Linux 网络 I/O 模型简介（图文）
热门推荐
anxpp的博客
05-26 3万+
1、介绍 Linux 的内核将所有外部设备都看做一个文件来操作（一切皆文件），对一个文件的读写操作会调用内核提供的系统命令，返回一个file descriptor（fd，文件描述符）。而对一个socket的读写也会有响应的描述符，称为socket fd（socket文件描述符），描述符就是一个数字，指向内核中的一个结构体（文件路径，数据区等一些属性）。 根据UNIX网络编程对I/O模型的分类，UNIX提供了5种I/O模型。 1.1、阻塞I/O模型 最常用的I/O模型，默认
socket阻塞与非阻塞，同步与异步、I/O模型
王伟挺的专栏
03-07 1228
socket阻塞与非阻塞，同步与异步 作者：huangguisu 1. 概念理解      在进行网络编程时，我们常常见到同步(Sync)/异步(Async)，阻塞(Block)/非阻塞(Unblock)四种调用方式： 同步：       所谓同步，就是在发出一个功能调用时，在没有得到结果之前，该调用就不返回。也就是必须一件一件事做,等前一件做完了
基于非阻塞I/O模型的服务器回射程序设计代码实现
最新发布
05-27
以下是一个基于非阻塞 I/O 模型的服务器回射程序的代码实现，使用 C 语言和 Linux 系统的 epoll 实现： ```c #include #include #include #include #include #include #include <arpa/inet.h> #include <sys/...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值