Linux之高级IO

爱被打了一巴掌 2022-06-08 01:07 235阅读 0赞

简述Linux5大IO模型

# 非阻塞IO #

> 非阻塞IO也就是当读取或者写低速设备时候，设备没有准备好的时候，读写函数直接错误返回，表示如果函数继续执行下去，那么将阻塞。

# 记录锁 #

> 记录锁是读写锁的一种扩展类型，可用于亲缘关系或无亲缘关系的进程之间共享某个文件的读与写。被锁住的文件通过文件描述符进行访问，执行上锁的操作函数是fcntl，这种类型的锁通常在内核中维护。  
> 　　记录锁的功能是：一个进程正在读或修改文件的某个部分时，可以阻止其他进程修改同一文件区，即其锁定的是文件的一个区域或整个文件。记录锁有两种类型：共享读锁，独占写锁。基本规则是：多个进程在一个给定的字节上可以有一把共享的读锁，但在一个给定字节上的写锁只能有一个进程独用。即：如果在一个给定的字节上已经有一把读或多把读锁，则不能在该字节上再加写锁；如果在一个字节上已经有一把独占性的写锁，则不能再对它加任何读锁。

采用Uinx打印假脱机处理系统举例说明记录锁的作用。打印假脱机处理系统使用技巧是给每台打印机准备一个文件，它只是一个单行执行的ASCII文本文件，其中还有待用的下一个序列号，需要给某个打印作业赋一个序列号的每个进程都得经历以下三个步骤：  
（1）读序列号文件  
（2）使用其中的序列号  
（3）给序列号加1并写回文件中  
存在问题：当某个进程在执行这个三个步骤时，另一个进程可能在执行同样的三个步骤，这将导致结果混乱。  
解决办法：一个进程能够设置某个锁，以宣称没有其他进程能够访问相应的文件，直到第一个进程完成访问为止。

//为了演示不加锁,所以函数内部没写
    void my_lock(int fd)
    {
        return;
    }
    void my_unlock(int fd)
    {
        return;
    }
    //读文件,然后数值加1,在写文件
    int main(int argc , char *argv[])
    {
        int fd;
        long i , seqno;
        pid_t pid;
        ssize_t n;
        char line[MAXLINE + 1];
        pid = getpid();//获取当前进程pid
        fd = open("seqno" , O_RDWR , FILE_MODE);//打开读写及权限文件
        for(i = 0 ; i < 2000 ; ++i){
            my_lock(fd);//这里实际没做事
            lseek(fd , 0L , SEEK_SET);//将文件偏移量设置为0
            n = read(fd , line , MAXLINE);//字节数目
            line[n] = '\0';//确保字符串结尾
            n = sscanf(line , "%ld\n" , &seqno);//格式转换
            //printf("%s:pid = %ld , seq = %ld\n" , argv[0] , (long)pid , seqno);//输出
            seqno++;
            snprintf(line , sizeof(line) , "%ld\n" , seqno);
            lseek(fd , 0L , SEEK_SET);//偏移量重新设置来写
            write(fd , line , strlen(line));//写入文件
            my_unlock(fd);
        }
        exit(0);
    }

![这里写图片描述][SouthEast]  
将seqno初始化为0，执行两次两次apue，假如锁生效的话，seqno应该等于4000，但是最后seqno输出2540，说明两个进程之间在同步访问，导致输出混乱。  
虽然上述可以用共享内存或者其他同步手段解决，但是这里我们仅仅使用记录锁搞定。

## Posix fcntl记录上锁 ##

struct flock
      {
        short int l_type;   /* Type of lock: F_RDLCK（共享读锁）, F_WRLCK（独占性写锁）, or F_UNLCK（解锁）.所希望锁类型 */
        short int l_whence; /* Where `l_start' is relative to (like `lseek'). */
        __off_t l_start;    /* Offset where the lock begins. */
        __off_t l_len;  /* Size of the locked area; zero means until EOF. 区域字节长度 */
        __pid_t l_pid;  /* Process holding the lock. */
      };
    
    /* cmd:对于记录锁为 F_GETLK：判断flockptr所描述的锁是否被另外一把锁排斥。测试能否建立一把锁 F_SETLK：设置由flockptr描述的锁。建立锁。 F_SETLKW：F_SETLK的阻塞版本。 第三个参数：是一个指向flock结构的指针。 成功：取决于cmd，出错返回-1 */
    int fcntl (int __fd, int __cmd, ...);

# IO复用 #

> 先构造一张我们感兴趣的描述符（通常不止一个）的列表，然后调用一个函数，阻塞等待直到这些描述符中有一个或者多个已经准备好进行I/O时，该函数才返回通知进程。poll、pselect、select三个函数可以执行I/O多路转接。从这些函数返回时，进程会被告知哪些描述符已经准备好可以进行I/O操作。当IO复用不等待时候，那么就称为轮询。函数调用很简单，但是系统内核实现起来可是非常复杂的东西，这里仅仅理解一些系统调用，我们是不是应该觉得很简单，所以我们一定要加油加油再加油。
> 
> 应用领域：客户处理多个描述符（交互式输入和网络套接字）；同时处理多个套接字；TCP服务器既要处理监听套接字也要处理已经链接的套接字等等。

## 1、select ##

系统调用select会一直阻塞，直到一个或者多个文件描述符集合成为就绪态。

/* 告诉内核一些信息：关心的描述符表，每一个描述符我们关心的条件（读，写，异常），愿意等多久。 内核返回一些信息：已经准备号描述符的总数量，各个条件下已经准备就绪的描述符。 __nfds：最大文件描述符编号值加1，也可以指定为FD_SETSIZE。指定最大内核可以在有效范围内搜索，这样select效率就更加高点。 __readfds：指向测试 读描述符集 指针 __writefds：指向测试 写描述符集 指针 __exceptfds：指向测试 异常描述符集 指针，某个套接字带外数据到达。 这三个参数都是值-结果形式，传入告诉内核测试哪些描述符，返回内核告诉你哪些描述符已经准备就绪，所以返回要再次使用select就必须重新设置。 __timeout：控制着select的阻塞行为。 __timeout==NULL，select永远等待描述符就绪 __timeout.tv_sec == 0 &&__timeout.tv_usec == 0根本不等待，测试指定描述符集合并立即返回。 __timeout.tv_sec != 0 || __timeout.tv_usec != 0等待指定秒及微妙，当指定描述符之一准备好或者指定时间值超时立即返回。 中间三个参数可以全部位NULL，表示不关心任何条件，此时提供比sleep更加精确的定时器。 返回值： -1：表示出错，例如描述符全部没准备好，捕捉到信号。 0：表示没有描述符准备好。指定描述符一个没有好且超时，这时候返回，描述符集全部清0。需要重新设定。 正值：说明已经由描述符准备好，值表示3个集合中处于就绪态fd的个数。如果同一个描述符测试读和写，那么计数两次。这样3个描述符集中仍旧打开的位对应于已准备好的描述符。 */
    int select (int __nfds, fd_set *__restrict __readfds,
               fd_set *__restrict __writefds,
               fd_set *__restrict __exceptfds,
               struct timeval *__restrict __timeout);
    
    #define FD_SET(fd, fdsetp)//将fd添加到fdset所指向的集合 
    #define FD_CLR(fd, fdsetp)//将fd从fdset所指向的集合移除 
    #define FD_ISSET(fd, fdsetp)//测试fdset集合中的fd描述符是否就绪，
    #define FD_ZERO(fdsetp)//将执行集合初始化为0
    //这四个宏定义用于设置fd_set对应的位。

#include <sys/types.h>
    #include <sys/socket.h>
    #include <netinet/in.h>
    #include <arpa/inet.h>
    #include <assert.h>
    #include <stdio.h>
    #include <unistd.h>
    #include <errno.h>
    #include <string.h>
    #include <fcntl.h>
    #include <stdlib.h>
    
    int main( int argc, char* argv[] )
    {
        if( argc <= 2 )
        {
            printf( "usage: %s ip_address port_number\n", basename( argv[0] ) );
            return 1;
        }
        const char* ip = argv[1];
        int port = atoi( argv[2] );
        printf( "ip is %s and port is %d\n", ip, port );
    
        int ret = 0;
        struct sockaddr_in address;
        bzero( &address, sizeof( address ) );
        address.sin_family = AF_INET;//协议簇
        inet_pton( AF_INET, ip, &address.sin_addr );//IP地址
        address.sin_port = htons( port );//端口号
        int listenfd = socket( AF_INET, SOCK_STREAM, 0 );//创建监听套接字
        ret = bind( listenfd, ( struct sockaddr* )&address, sizeof( address ) );//绑定地址信息
        assert( ret != -1 );
    
        ret = listen( listenfd, 5 );//监听
        assert( ret != -1 );
        struct sockaddr_in client_address;//存储客户机IP地址信息
        socklen_t client_addrlength = sizeof( client_address );
    
       char buf[1024];
       fd_set read_fds;//读符号集
       fd_set exception_fds;//异常符号集
       FD_ZERO( &read_fds );//清0
       FD_ZERO( &exception_fds );//清0
    
        int nReuseAddr = 1;
        setsockopt( connfd, SOL_SOCKET, SO_OOBINLINE, &nReuseAddr, sizeof( nReuseAddr ) );//设定套接字接收带外数据在线保存
        while( 1 )
        {
        int connfd = accept( listenfd, ( struct sockaddr* )&client_address, &client_addrlength );//阻塞与accept，等待客户机连接
        if ( connfd < 0 )
        {
            printf( "errno is: %d\n", errno );
            close( listenfd );
        }
        char remote_addr[INET_ADDRSTRLEN];
        printf( "connected with ip: %s and port: %d\n", inet_ntop( AF_INET, &client_address.sin_addr, remote_addr, INET_ADDRSTRLEN ), ntohs( client_address.sin_port ) );
            memset( buf, '\0', sizeof( buf ) );
            FD_SET( connfd, &read_fds );
            FD_SET( connfd, &exception_fds );
            ret = select( connfd + 1, &read_fds, NULL, &exception_fds, NULL );
            printf( "select one\n" );
                if ( ret < 0 )
                {
                        printf( "selection failure\n" );
                        break;
                }
    
            if ( FD_ISSET( connfd, &read_fds ) )
            {
                ret = recv( connfd, buf, sizeof( buf )-1, 0 );
                if( ret <= 0 )
                {
                    break;
                }
                printf( "get %d bytes of normal data: %s\n", ret, buf );
            }
            else if( FD_ISSET( connfd, &exception_fds ) )
                {
                    ret = recv( connfd, buf, sizeof( buf )-1, MSG_OOB );
                if( ret <= 0 )
                {
                    break;
                }
                printf( "get %d bytes of oob data: %s\n", ret, buf );
                }
    
        }
        close( connfd );
        close( listenfd );
        return 0;
    }

通过select处理正常读和带外数据异常的情况，这些过程都是固定的系统调用，不必死记住，需要使用的时候，就查询即可。

## 2、poll ##

与select相比设定待检测的文件描述符方式不同。

/* 与select类似，但是可用于任何类型文件描述符。 并不是为每一个条件构造描述符集合，而是构造一个结构体数组，其中每一个元素对应一个描述符编号以及对该描述符感兴趣的测试条件。 __timeout：指定等待时间 ==-1：用于等待 ==0：不等待，轮询系统方法。 >0：等待毫秒 */
    struct pollfd
      {
        int fd;         /* File descriptor to poll. */
        short int events;/*感兴趣条件，设置对应头文件宏*/
        short int revents;/*由内核设置，返回内核告诉events哪些条件发生了*/
      };
    int poll (struct pollfd *__fds, nfds_t __nfds, int __timeout);

## 3、epoll ##

epoll是Linux特有的I/O复用函数，用法上epoll使用一组函数完成任务，而不是单个函数。epoll把用户关心的文件描述符上的事件放在内核里的一个事件表中，从而无须像select和poll那样每次调用都要重复传入文件描描述符就事件集。

/* size:指定通过epoll实例来检查的文件描述符个数。参数并不是一个上限，而是告诉内核应该如何为内部数据结构划分初始化大小。 返回值：返回epoll实例的文件描述符。当此文件描述符不需要应该close。 */
    int epoll_create (int __size) __THROW;
    
    
    /* 修改文件描述符epfd所代表的epoll实例中的兴趣列表。 __epfd： __op：指定执行的操作 #define EPOLL_CTL_ADD 1//将fd添加到epfd，对于fd感兴趣的事件都定义在event中 #define EPOLL_CTL_DEL 2//从epfd中删除fd，忽略event参数，关闭fd，描述符自动移除 #define EPOLL_CTL_MOD 3 //修改fd对应感兴趣的事件 __fd：文件描述符 __event：对应感兴趣事件描述及个人数据（个人数据将在epoll_wait中返回），个人数据通常存放文件描述符。 返回：0成功，-1失败。并将errno设置为？？？，可供程序检查 */
    typedef union epoll_data
    {
      void *ptr;
      int fd;
      uint32_t u32;
      uint64_t u64;
    } epoll_data_t;
    struct epoll_event//指定fd对应的感兴趣事件
    {
      uint32_t events;  /* Epoll events */
      epoll_data_t data;    /* User data variable */
    } __EPOLL_PACKED;
    extern int epoll_ctl (int __epfd, int __op, int __fd,
                  struct epoll_event *__event) __THROW;
    
    /* 返回epfd实例中处于就绪态的文件描述符信息。 __epfd：epfd实例文件描述符。 __events：每个元素返回有关就绪态文件描述符信息，由调用函数分配内存。__events[]应该为数组，内部events成员返回发生事件掩码，data成员返回的是在epoll_ctl注册感兴趣事件时候__event.data所指定的值。data字段是唯一可获知事件文件描述符的途径，所以ev.data.fd设为文件描述符，或者将ev.data.ptr设为包含文件描述符的结构体。 __maxevents：指针上面数组元素个数。 __timeout：确定epoll阻塞行为。 -1：一直阻塞，直到感兴趣列表事件发生或捕捉一个信号 0：执行依次非阻塞检查，并立即返回 >0:最多阻塞这个值。 返回值：成功返回__events数组中元素个数。出错返回1，超时没有就绪则为0。 */
    int epoll_wait (int __epfd, struct epoll_event *__events,
                   int __maxevents, int __timeout);

![这里写图片描述][70]

## 4、LT和ET ##

epoll对于文件描述符有两种操作。水平触发（默认方式）和边沿触发。

#include <sys/types.h>
    #include <sys/socket.h>
    #include <netinet/in.h>
    #include <arpa/inet.h>
    #include <assert.h>
    #include <stdio.h>
    #include <unistd.h>
    #include <errno.h>
    #include <string.h>
    #include <fcntl.h>
    #include <stdlib.h>
    #include <sys/epoll.h>
    #include <pthread.h>
    
    #define MAX_EVENT_NUMBER 1024
    #define BUFFER_SIZE 10
    
    int setnonblocking( int fd )
    {
        int old_option = fcntl( fd, F_GETFL );
        int new_option = old_option | O_NONBLOCK;
        fcntl( fd, F_SETFL, new_option );
        return old_option;
    }
    
    void addfd( int epollfd, int fd, bool enable_et )
    {
        epoll_event event;
        event.data.fd = fd;//传入文件描述符
        event.events = EPOLLIN;//监听读
        if( enable_et )//文件描述通过ET监听
        {
            event.events |= EPOLLET;//加入ET即可
        }
        epoll_ctl( epollfd, EPOLL_CTL_ADD, fd, &event );//添加事件
        setnonblocking( fd );//设定为非阻塞
    }
    
    void lt( epoll_event* events, int number, int epollfd, int listenfd )
    {
        char buf[ BUFFER_SIZE ];
        for ( int i = 0; i < number; i++ )
        {
            int sockfd = events[i].data.fd;
            if ( sockfd == listenfd )//listenfd就绪，就是证明有新的连接，然后需要加入进来
            {
                struct sockaddr_in client_address;
                socklen_t client_addrlength = sizeof( client_address );
                int connfd = accept( listenfd, ( struct sockaddr* )&client_address, &client_addrlength );//返回最新的队列。
                addfd( epollfd, connfd, false );//将connfd套接字加入epoll使用LT模式，这是一个客户连接的描述符
            }
            //只要socket还有数据，下次还是会被重复触发。
            else if ( events[i].events & EPOLLIN )//如果有数据到来
            {
                printf( "event trigger once\n" );
                memset( buf, '\0', BUFFER_SIZE );
                int ret = recv( sockfd, buf, BUFFER_SIZE-1, 0 );//读数据
                if( ret <= 0 )
                {
                    close( sockfd );//并关闭sockfd
                    continue;
                }
                printf( "get %d bytes of content: %s\n", ret, buf );
            }
            else
            {
                printf( "something else happened \n" );
            }
        }
    }
    
    void et( epoll_event* events, int number, int epollfd, int listenfd )
    {
        char buf[ BUFFER_SIZE ];
        for ( int i = 0; i < number; i++ )
        {
            int sockfd = events[i].data.fd;
            if ( sockfd == listenfd )
            {
                struct sockaddr_in client_address;
                socklen_t client_addrlength = sizeof( client_address );
                int connfd = accept( listenfd, ( struct sockaddr* )&client_address, &client_addrlength );
                addfd( epollfd, connfd, true );//加入，通过ET模式
            }
            else if ( events[i].events & EPOLLIN )
            {
                //这段代码不会被重复触发，所以必须将数据读完。
                printf( "event trigger once\n" );
                while( 1 )
                {
                    memset( buf, '\0', BUFFER_SIZE );
                    int ret = recv( sockfd, buf, BUFFER_SIZE-1, 0 );
                    if( ret < 0 )
                    {
                        if( ( errno == EAGAIN ) || ( errno == EWOULDBLOCK ) )
                        {
                            printf( "read later\n" );
                            break;
                        }
                        close( sockfd );
                        break;
                    }
                    else if( ret == 0 )
                    {
                        close( sockfd );
                    }
                    else
                    {
                        printf( "get %d bytes of content: %s\n", ret, buf );
                    }
                }
            }
            else
            {
                printf( "something else happened \n" );
            }
        }
    }
    
    int main( int argc, char* argv[] )
    {
        if( argc <= 2 )
        {
            printf( "usage: %s ip_address port_number\n", basename( argv[0] ) );
            return 1;
        }
        const char* ip = argv[1];
        int port = atoi( argv[2] );
    
        int ret = 0;
        struct sockaddr_in address;
        bzero( &address, sizeof( address ) );
        address.sin_family = AF_INET;
        inet_pton( AF_INET, ip, &address.sin_addr );
        address.sin_port = htons( port );
    
        int listenfd = socket( PF_INET, SOCK_STREAM, 0 );
        assert( listenfd >= 0 );
    
        ret = bind( listenfd, ( struct sockaddr* )&address, sizeof( address ) );
        assert( ret != -1 );
    
        ret = listen( listenfd, 5 );
        assert( ret != -1 );
    
        epoll_event events[ MAX_EVENT_NUMBER ];
    
        int epollfd = epoll_create( 5 );
        assert( epollfd != -1 );
    
        addfd( epollfd, listenfd, true );//将listenfd加入epoll
    
        while( 1 )
        {
            int ret = epoll_wait( epollfd, events, MAX_EVENT_NUMBER, -1 );//一直阻塞，直到事件就绪
            if ( ret < 0 )
            {
                printf( "epoll failure\n" );
                break;
            }
    
            lt( events, ret, epollfd, listenfd );
            //et( events, ret, epollfd, listenfd );
        }
    
        close( listenfd );
        return 0;
    }

上述这点代码介绍了epoll的使用，以及ET模式和LT模式的不同。telnet 到这个服务器程序上并一次传输超过10字节( BUFFER SIZE 的大小）的数据，然后比较LT模式和 ET模式的异同。你会发现，正如我们预期的，ET模式下事件被触发的次数要比LT模式下少很多。每个使用ET模式的文件描述符都应该是非阻塞的 。如果文件描述符是阻塞的 ，那么读或写操作将会因为没有后续的事件，而一直处于阻塞状态 （饥渴状态 )。

## 5、EPOLLONESHOT事件 ##

将一个socket总是分配给某一个线程处理。  
![这里写图片描述][70 1]

#include <sys/types.h>
    #include <sys/socket.h>
    #include <netinet/in.h>
    #include <arpa/inet.h>
    #include <assert.h>
    #include <stdio.h>
    #include <unistd.h>
    #include <errno.h>
    #include <string.h>
    #include <fcntl.h>
    #include <stdlib.h>
    #include <sys/epoll.h>
    #include <pthread.h>
    
    #define MAX_EVENT_NUMBER 1024
    #define BUFFER_SIZE 1024
    struct fds
    {
       int epollfd;
       int sockfd;
    };
    
    int setnonblocking( int fd )//将fd设为非阻塞
    {
        int old_option = fcntl( fd, F_GETFL );
        int new_option = old_option | O_NONBLOCK;
        fcntl( fd, F_SETFL, new_option );
        return old_option;
    }
    
    void addfd( int epollfd, int fd, bool oneshot )
    {
        epoll_event event;
        event.data.fd = fd;
        event.events = EPOLLIN | EPOLLET;
        if( oneshot )
        {
            event.events |= EPOLLONESHOT;//设为此描述符仅仅让一个工作线程占有，防止多个线程操作一个socket。
        }
        epoll_ctl( epollfd, EPOLL_CTL_ADD, fd, &event );
        setnonblocking( fd );
    }
    
    //重置fd上的事件
    void reset_oneshot( int epollfd, int fd )//重置socket，使得可以再次被监听
    {
        epoll_event event;
        event.data.fd = fd;
        event.events = EPOLLIN | EPOLLET | EPOLLONESHOT;
        epoll_ctl( epollfd, EPOLL_CTL_MOD, fd, &event );
    }
    
    void* worker( void* arg )
    {
        int sockfd = ( (fds*)arg )->sockfd;
        int epollfd = ( (fds*)arg )->epollfd;
        printf( "start new thread to receive data on fd: %d\n", sockfd );
        char buf[ BUFFER_SIZE ];
        memset( buf, '\0', BUFFER_SIZE );
        //循环读取sockfd上的数据，直到遇到EAGAIN错误，证明读完了
        while( 1 )
        {
            int ret = recv( sockfd, buf, BUFFER_SIZE-1, 0 );
            if( ret == 0 )
            {
                close( sockfd );
                printf( "foreiner closed the connection\n" );
                break;
            }
            else if( ret < 0 )
            {
                if( errno == EAGAIN )//读完了
                {
                    reset_oneshot( epollfd, sockfd );//重新注册EPOLLONESHOT
                    printf( "read later\n" );
                    break;
                }
            }
            else
            {
                printf( "get content: %s\n", buf );
                //休眠5s，默认数据处理过程
                sleep( 5 );
            }
        }
        printf( "end thread receiving data on fd: %d\n", sockfd );
    }
    
    int main( int argc, char* argv[] )
    {
        if( argc <= 2 )
        {
            printf( "usage: %s ip_address port_number\n", basename( argv[0] ) );
            return 1;
        }
        const char* ip = argv[1];
        int port = atoi( argv[2] );
    
        int ret = 0;
        struct sockaddr_in address;
        bzero( &address, sizeof( address ) );
        address.sin_family = AF_INET;
        inet_pton( AF_INET, ip, &address.sin_addr );
        address.sin_port = htons( port );
    
        int listenfd = socket( PF_INET, SOCK_STREAM, 0 );
        assert( listenfd >= 0 );
    
        ret = bind( listenfd, ( struct sockaddr* )&address, sizeof( address ) );
        assert( ret != -1 );
    
        ret = listen( listenfd, 5 );
        assert( ret != -1 );
    
        epoll_event events[ MAX_EVENT_NUMBER ];
    
        int epollfd = epoll_create( 5 );
        assert( epollfd != -1 );
        //监听listenfd，不能注册EPOLLONESHOT，否则一个客户只能处理一个连接，因为后续客户连接请求将不再触发。
        addfd( epollfd, listenfd, false );
    
        while( 1 )
        {
            int ret = epoll_wait( epollfd, events, MAX_EVENT_NUMBER, -1 );
            if ( ret < 0 )
            {
                printf( "epoll failure\n" );
                break;
            }
    
            for ( int i = 0; i < ret; i++ )
            {
                int sockfd = events[i].data.fd;
                if ( sockfd == listenfd )
                {
                    struct sockaddr_in client_address;
                    socklen_t client_addrlength = sizeof( client_address );
                    int connfd = accept( listenfd, ( struct sockaddr* )&client_address, &client_addrlength );
                    addfd( epollfd, connfd, true );
                }
                else if ( events[i].events & EPOLLIN )
                {
                    pthread_t thread;
                    fds fds_for_new_worker;
                    fds_for_new_worker.epollfd = epollfd;
                    fds_for_new_worker.sockfd = sockfd;
                    pthread_create( &thread, NULL, worker, ( void* )&fds_for_new_worker );//创建一个工作线程
                }
                else
                {
                    printf( "something else happened \n" );
                }
            }
        }
    
        close( listenfd );
        return 0;
    }

![这里写图片描述][70 2]

## 6、比较三种IO复用 ##

![这里写图片描述][70 3]  
![这里写图片描述][70 4]  
![这里写图片描述][70 5]  
![这里写图片描述][70 6]

# 异步IO #

> 告知内核启动某个操作，并让内核在整个操作（包含将数据复制到自己的缓冲区）完成后通知我们并调用注册的信号处理函数。这里系统实现较少，仅仅对比与信号驱动式IO模型。

# 函数readv、readn和writev、writen #

> readv和writev函数用于在一次函数调用中读、写多个非连续缓冲区。有时也将这两个函数称为散布读( scatter read) 和聚集写 (gather write) 。

readv和writev系统调用：

/* __iovec：指向结构体数组指针。 __count：结构体数据中元素个数，受限于IOV_MAX writev聚集（将分散缓冲区写入一个fd）输出数据依次是__iovec[0],__iovec[1]...返回输出的字节总数，通常应该是所有缓冲区长度之和。 readv函数则将读入的数据按上述同样顺序散布（fd数据散步到缓冲区）到缓冲区中。 readv总是先填满一个缓冲区，然后再填写下一个。readv返回读到的字节总数。如果遇到文件尾端，已无数据可读，则返回0。 */
    struct iovec
    {
       void *iov_base;  /* 缓冲区首地址 */
       size_t iov_len;  /* 缓冲区长度 */
    };
    ssize_t readv (int __fd, const struct iovec *__iovec, int __count);
    ssize_t writev (int __fd, const struct iovec *__iovec, int __count);

readn和writen并非系统调用：  
需要使用再讨论这个作者自定义的函数

这里写代码片

# 存储映射IO #

> 存储映射I/O能将一个磁盘文件映射到存储空间中的一个缓冲区上，当从缓冲区中读取数据时，就相当于读磁盘文件中的相应字节，当数据存入缓冲区时，就相当于将磁盘文件中写入相应的字节。这样，就可以在不使用 read 和 write 的情况下执行I/O操作。功能由mmap实现。

/* __addr：指定映射存储区起始地址，通常设置为0表示由内核选择起始地址。 __len：映射字节数。 __prot：指定映射存储区的保护要求，可以指定位下面宏定义按位或。 #define PROT_READ 0x1 //Page can be read. #define PROT_WRITE 0x2 // Page can be written. #define PROT_EXEC 0x4 // Page can be executed. #define PROT_NONE 0x0 // Page can not be accessed. __flags：指定映射存储区属性 MAP_FIXED：返回值必须等于addr，并不利于移植，所以一般不用。 MAP_SHARED：指定存储操作相对于对文件write。 MAP_PRIVATE：指定存储操作导致创建映射文件私有副本，后来对映射区引用都是引用该副本。通常用于调试程序。 __fd：指定要被映射文件的描述符，映射之前必须打开该文件。 __offset：映射字节再文件中的起始偏移量。 返回：返回该映射区的起始地址。 */
    void *mmap (void *__addr, size_t __len, int __prot,
               int __flags, int __fd, __off_t __offset);
    /* 修改一个现有映射的权限。 addr：必须是页长的整数倍。 */
    nt mprotect (void *__addr, size_t __len, int __prot);
    
    /* 将页冲洗到被映射的文件中。 flags：指定下面标识。 #define MS_ASYNC 1 //执行异步写，写操作已有内核排入队列，立即返回 #define MS_SYNC 4 //执行同步写，写操作完成后才返回 MS_ASYNC和MS_SYNC必须选择一个 #define MS_INVALIDATE 2 //使高速缓存数据失效。 */
    int msync (void *__addr, size_t __len, int __flags);
    
    //进程终止时，会自动解除存储映射区的映射，或者调用此函数解除映射区。
    int munmap (void *__addr, size_t __len);

![这里写图片描述][SouthEast 1]  
映射存储区位于堆和栈之间。flag参数影响映射存储区属性。

1、父子进程在内存映射文件中给计数器持续加1，利用有名信号量同步，信号量不必放在映射内存，信号量在内核中。  
因为映射属性是共享，所以在内存中操作，会反应到实际文件中。

#define SEMNAME "mysem"
    int main(int argc, char *argv[])
    {
        sem_t *mutex;
        int i , nloop , fd , zero = 0;
        int *ptr;
        if(argc != 2){
            err_sys("pra error");
        }
        nloop = atoi(argv[1]);
        fd = Open("shem" , O_RDWR|O_CREAT , FILE_MODE);//打开一个文件，并且创建
        Write(fd , &zero , sizeof(int) );//将文件数据清0
        //对ptr操作会反应到真正的文件之中，所以可以父子进程同步。只要和准确的路径有关，那么进程，线程都可以访问
        ptr = (int *)Mmap(NULL , sizeof(int) , PROT_READ|PROT_WRITE , MAP_SHARED , fd , 0);//初始化内存映射，将文件映射到内存空间。那么ptr由进程共享
        Close(fd);
        mutex = Sem_open(SEMNAME , O_CREAT|O_EXCL , FILE_MODE , 1 );//初始一个信号量
        Sem_unlink(SEMNAME);//删除名字，但是不会影响打开的mutex。
        setbuf(stdout , NULL);//不加缓冲输出
        if( Fork() == 0 ){
       //child
            for(i = 0 ; i< nloop ; ++i ){
                Sem_wait(mutex);//获取信号量
                printf("child: %d\n" , (*ptr)++);
                Sem_post(mutex);//释放信号量
            }
            exit(0);
        }//父进程
        for(i = 0 ; i< nloop ; ++i ){
            Sem_wait(mutex);//获取信号量
            printf("parent: %d\n" , (*ptr)++);
            Sem_post(mutex);//释放信号量
        }
        sleep(5);
        exit(0);
    }

![这里写图片描述][SouthEast 2]  
![这里写图片描述][SouthEast 3]  
从上图可以看出，运行程序之后，创建了一个文件和内存映射相关联。父子进程都各有又属于自己的ptr副本，但是每一个副本指向共享内存去同一个区域，所以操作ptr实际上就反应到了shemfile里面。可以看出此时文件里面内容是 20 0 0 0。因为信号量具有内核属性，所以既可以放在外面也可以放在共享内存中。  
Asic表：  
![这里写图片描述][SouthEast 4]  
0-32是不可显示字符。vim为了显示所有字符，将不可显示字符编码加上 64 之后对应的全部为可打印字符，于是将 0-31 位置的字符，用^跟转换之后对应的那个字符绑在一起当作一个字符显示出来，既简洁又实用，——是为“脱字符表示法”。于是20对应vim里面的^T(20+64)。

2、父子进程在内存映射文件中给计数器持续加1，利用基于内存（匿名）信号量同步，信号量必放在映射内存，也就是将信号量从内核移到了共享内存区。

struct shared{
        sem_t mutex;//分配一个实际的区域，而不是一个指针变量，这里一定要注意。
        int count;
    }shared;
    
    int main(int argc, char *argv[])
    {
        int i , nloop , fd , zero = 0;
        struct shared *ptr;//映射
        if(argc != 2){
            err_sys("pra error");
        }
        nloop = atoi(argv[1]);
        fd = Open("shemfile" , O_RDWR|O_CREAT , FILE_MODE);//打开一个文件，并且创建
        Write(fd , &shared , sizeof(struct shared) );//将文件数据清0，注意这里清0一定注意
        //对ptr操作会反应到真正的文件之中，所以可以父子进程同步。只要和准确的路径有关，那么进程，线程都可以访问
        ptr = (struct shared *)Mmap(NULL , sizeof(struct shared) , PROT_READ|PROT_WRITE , MAP_SHARED , fd , 0);//初始化内存映射，将文件映射到内存空间。那么ptr由进程共享
        Close(fd);
        Sem_init(&ptr->mutex , 1 , 1);
        setbuf(stdout , NULL);//不加缓冲输出
        if( Fork() == 0 ){
       //child
            for(i = 0 ; i< nloop ; ++i ){
                Sem_wait(&ptr->mutex);//获取信号量
                printf("child: %d\n" , (ptr->count)++);
                Sem_post(&ptr->mutex);//释放信号量
            }
            exit(0);
        }//父进程
        for(i = 0 ; i< nloop ; ++i ){
            Sem_wait(&ptr->mutex);//获取信号量
            printf("parent: %d\n" , (ptr->count)++);
            Sem_post(&ptr->mutex);//释放信号量
        }
        sleep(5);
        exit(0);
    }

信号量的属性，这里应该注意，有名信号量，因为有具体路径，所以进程和线程都可以看到；匿名信号量，只有创建的进程和多个线程可见，因为没有具体路径，找不到。

[SouthEast]: /images/20220608/e1f87da36aa84e10a2eca2c9c50cca79.png
[70]: /images/20220608/f3e97c3d471f426dac426ff551b7180e.png
[70 1]: /images/20220608/f91cfa212cd74f80aea471c479bbf60a.png
[70 2]: /images/20220608/2819c9c8f8964bd58730889cc6c3ce18.png
[70 3]: /images/20220608/6a556a47f68947c6b2ffebdce8f42a8e.png
[70 4]: /images/20220608/d29a7adb03f4409c8e28104f9df0f2cf.png
[70 5]: /images/20220608/42137edc5bc9403eb4e16dbcebe75c8a.png
[70 6]: /images/20220608/2481c84baaed47a3bc786a8c3dda68e2.png
[SouthEast 1]: /images/20220608/448a354f57134d33811a9fc7932bac50.png
[SouthEast 2]: /images/20220608/bd515334b2dc4fb19ff19f0c6622f931.png
[SouthEast 3]: /images/20220608/6b25ff33310c4e4ca00294eca389a56b.png
[SouthEast 4]: /images/20220608/a2119995c9fd4715a476836b82520ad2.png