Linux基础(06)IO复用

在Windows文件指的就是普通的肉眼可见的文件 , 而Linux一切皆文件　　https://blog.csdn.net/nan_nan_nan_nan_nan/article/details/81233599

一定要注意生成文件的警告和报错,不能忽略了!!!!!!!

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

int main(int argc, char *argv[])
{
    FILE* fp;
    char buf[]="hello world";
    char buff2[128];
    if((fp = fopen("1.txt","w+")) == NULL)
    {
        perror("file open failure");
        exit(1);
    }
    fwrite(buf , sizeof(buf), 1 , fp);
    memset(buff2,0,sizeof(buff2));
    fseek(fp,0,SEEK_SET);
    fread(buff2 ,sizeof(buff2) ,1, fp);
    printf(">>%s
",buff2);
    getchar();
    fclose(fp);
    return 0;
}

1.标准流和流功能　　write和read 可以对任何文件读写

　　stdin　　0　　标准输入

　　stdout　　1　　标准输出

　　stderr　　2　　标准错误(报错)

　　可以使用write代替printf , printf是实现比较复杂局限性也小

　　write(目的/0, buff , length)　　目的是写入的目标文件或使用上面的std进行打印和输出到控制台 , buff是要写入的数据 , length是写入的大小

　　FILE* 是指向一个内存　　open返回的是一个句柄

---

2.缓冲区

　　1.缓冲区又称为缓存，它是内存空间的一部分。也就是说，在内存空间中预留了一定的存储空间，这些存储空间用来缓冲输入或输出的数据，这部分预留的空间就叫做缓冲区。缓冲区根据其对应的是输入设备还是输出设备，分为输入缓冲区和输出缓冲区。

　　2.缓冲区有分为下列几种

　　_IOFBF 全缓冲　 | 全缓冲区 默认大小BUFSIZE 4096　　fflush() https://baike.baidu.com/item/fflush/10942194?fr=aladdin　　默认开启全缓冲区

　　_ IOLBF 行缓冲　| 行缓冲区 遇到换行符才进行刷新 参考Linux终端和scanf

　　_IONBF 无缓冲　| 无缓冲区 stdio库 参考read, write ,stderr 都是不带缓冲区的

　　指定缓冲区　setbuf(FILE* stream , char* buf);　　buf的长度必须是指向长度为BUFSIZE的缓冲区

　　　　　　　　setbuffer(FILE* stream , char* buf , size_t size);

　　　　　　　　setlinebuf(FILE* stream);

　　3.设置缓冲区的函数

　　　　void setbuf(FILE *stream, char *buf);
　　　　void setbuffer(FILE *stream, char *buf, size_t size);
　　　　void setlinebuf(FILE *stream);
　　　　int setvbuf(FILE *stream, char *buf, int mode , size_t size);

　　4.为什么使用setvbuf函数　　

　　如果你的内存足够大，可以把文件IO的BUF设置大一些，这样每次你用fopen/fread/fwrite/fscanf/fprintf语句的时候，都会在内存里操作，减少内存到磁盘IO读写的操作次数，提高系统效率。如果你的程序的功能涉及到类似数据库、视频、音频、图像处理等大量需要爆发式磁盘到内存的IO情况下，可以考虑用setvbuf进行优化内存IO，其他情况下可以不考虑，LINUX/WINDOWS会自动处理这些问题。

---

3.fopen的权限　　https://blog.csdn.net/gettogetto/article/details/72867757

　　函数原型：FILE * fopen(const char * path,const char * mode);

　　mode:

　　“r” 以只读方式打开文件，该文件必须存在。

　　“r+” 以可读写方式打开文件，该文件必须存在。
　　”rb+“ 读写打开一个二进制文件，允许读写数据（可以任意修改），文件必须存在。
　　“w” 打开只写文件，若文件存在则文件长度清为0，即该文件内容会消失。若文件不存在则建立该文件。
　　“w+” 打开可读写文件，若文件存在则文件长度清为零，即该文件内容会消失。若文件不存在则建立该文件。
　　“a” 以附加的方式打开只写文件。若文件不存在，则会建立该文件，如果文件存在，写入的数据会被加到文件尾，即文件原先的内容会被保留。（EOF符保留）
　　”a+“ 以附加方式打开可读写的文件。若文件不存在，则会建立该文件，如果文件存在，写入的数据会被加到文件尾后，即文件原先的内容会被保留。 （原来的EOF符不保留）
　　“wb” 只写打开或新建一个二进制文件；只允许写数据（若文件存在则文件长度清为零，即该文件内容会消失）。
　　“wb+” 读写打开或建立一个二进制文件，允许读和写（若文件存在则文件长度清为零，即该文件内容会消失）
　　“ab” 追加打开一个二进制文件，并在文件末尾写数据
　　“ab+” 读写打开一个二进制文件，允许读，或在文件末追加数据

---

4.文件读写函数

　　write read (fd , buff , size(buff));　　任何文件都可读写 如:txt ,套接字等等...　　

　　fwrite fread (buff , sizeof(buff), 1 , fp);　只能读写标准文件

　　fgetc和getc他们的区别并不是在他们的使用上，而是在他们的实现上！具体来说，就是带f的(fgetc、fputc)实现的时候是通过函数来实现的，而不带f(putc、getc)的实现的时候是通过宏定义来实现的！

　　char *gets(char *str) 从标准输入 stdin 读取一行，并把它存储在 str 所指向的字符串中。当读取到换行符时，或者到达文件末尾时，它会停止，具体视情况而定。

　　char *fgets(char *str, int n, FILE *stream) 从指定的流 stream 读取一行，并把它存储在 str 所指向的字符串内。当读取 (n-1) 个字符时，或者读取到换行符时，或者到达文件末尾时，它会停止。

　　int getc(FILE *stream) 　　int fgetc(FILE *stream) 从指定的流 stream 获取下一个字符（一个无符号字符），并把位置标识符往前移动。

　　int fputs(const char *str, FILE *stream) 把字符串写入到指定的流 stream 中，但不包括空字符。

　　int puts(const char *str) 把一个字符串写入到标准输出 stdout，直到空字符，但不包括空字符。换行符会被追加到输出中。

　　int fputc(int char, FILE *stream)　　int putc(int char, FILE *stream)  把参数 char 指定的字符（一个无符号字符）写入到指定的流 stream 中，并把位置标识符往前移动。

---

 5.文件流定位

　　iint fseek(FILE *stream, long int offset, int whence) 设置流 stream 的文件位置为给定的偏移 offset，参数 offset 意味着从给定的 whence 位置查找的字节数。

　　　　whence :  (SEEK_SET  文件开始的位置)(SEEK_CUR 文件的当前位置)(SEEK_END 文件结束的的位置)

　　long int ftell(FILE *stream) 返回文件读写指针当前的位置距离开头的字节数

　　void rewind(FILE *stream) 设置文件位置为给定流 stream 的文件的开头。

　　需求:  获得当前文件的真实大小 实现:fseek到文件end 再 ftell 获得

---

6.标准文件和socket文件的区别和联系　　以上所述都是标准的IO , 以下的是socketIO

　　区别:

　　　　文件的量 不同　　(网络文件的量更加庞大)

　　　　处理的实时性要求不同　　(文件不能提前获取(如电影缓冲好的和未缓冲好的区别) , 标准文件是以阻塞的方式进行的在网络文件行不通)

　　　　

　　联系: 都是文件可以使用相同的函数

---

7.socket的IO模型　　IO模型　https://www.cnblogs.com/LittleHann/p/3897910.html

　　　　　　　　　　阻塞非阻塞区别　https://baijiahao.baidu.com/s?id=1623908582750588151&wfr=spider&for=pc

　　　　　　　　　　　　　　　　　　以下对照IO模型

阻塞IO处理　　 如: read() 如果没有收到对端数据 , 内核会处于挂起状态直到有数据才会往下执行

非阻塞IO处理　如: 把read()设置成非阻塞 无论是否收到数据都会立刻返回,再不断的访问socket(也是一种阻塞) ,直到有数据才往下执行

IO复用式　　　　一个IO复用到多个IO , 并一起等待 , 一个文件夹里有多个文件,一起阻塞到内核里

信号驱动式IO　　不等待socket是否有数据, 当socket有数据时会发起信号并优先处理数据

信号驱动式IO:　　当在执行程序时, 绑定的信号IO发起信号时, 挂起当前执行的程序去处理发起信号的IO,处理完信号后再继续之前的操作

异步IO:　　前面所述都会占用IO,一直等待内核拷贝完数据返回后才执行下个IO 无法同时并发处理多个IO

　　　　　同步IO在同一时刻只允许一个IO操作，也就是说对于同一个文件句柄的IO操作是序列化的，即使使用两个线程也不能同时对同一个文件句柄同时发出读

　　　　　写操作。异步文件IO也就是重叠IO允许一个或多个线程同时发出IO请求。

　　　　　异步文件IO方式中，线程发送一个IO请求到内核，然后继续处理其他的事情，内核完成IO请求后，将会通知线程IO操作完成了

---

8.IO复用的使用与流程

 IO复用:　　IO复用是把多个IO的fd加入到fd_set这个文件集里,多个IO共同使用一个select的fd (一起阻塞), select()轮询fd_set , 但凡有数据的IO则立刻返回

　　　　　　select poll epoll 

　　　　selcet函数是一个轮循函数，即当循环询问文件节点，可设置超时时间，超时时间到了就立刻返回往下执行

　　　　select()的详解　https://blog.csdn.net/jiaqi_327/article/details/25657601

　　　　　　　分配 struct fd_set rfds;　　创建IO复用的文件集

　　　　　　　设置  初始化FD_ZERO(&rfds);　　加入句柄FD_SET(fd , &rfds);把fd加入到rfds　　移除句柄FD_CLR(fd, &rfds));把fd移出rfds

　　　　　　　使用  int select(int nfds, fd_set *readfds, fd_set *writefds,fd_set *exceptfds, struct timeval *timeout);　　　　　　　　　　　

　　　　　　　　　　　　　　int nfds 文件集合中文件描述符最大值(fd是int类型,每个进程默认有3个标准fd,从3开始+1)+1

　　　　比如stdin(0) , stdout(1) , 因为select的起始位置不同,fd是从0开始的 ,select是从1开始所以要+1(0+1才能指向stdin代表第一个fd)

　　　　　　　　　　　　　　freadfds, writefds, exceptfds 是可读文件节点集, 可写文件节点集, 检查节点错误集,(给freadfds参数就行了其他NULL)
　　　　　　　　　　　　　　struct timeval *timeout　　设置select的间隔时间,超过时间立刻返回
　　　　　　　　　　　　　　struct timeval {　 创建对象设置好后传入
　　　　　　　　　　　　　　　　　　　　　　long tv_sec; /* seconds */　　秒
　　　　　　　　　　　　　　　　　　　　　　long tv_usec; /* microseconds */　　微秒};

　　　　　int FD_ISSET(int fd, fd_set *set)是一个宏,不是函数，作用就是检察一下现在是否有数据可读。 　通过select返回后(证明有数据)不再进行阻塞

　　　　　　　　　　　　经过第一次select后 , 每次重新select之前都要重新加入FD_SET ,因为select会改变rfds里的值

　　　inet_aton(const char* cp,struct in_addr* inp) 将cp所指的网络地址字符串转换成网络使用的二进制的数,然后存于inp所指的in_addr结构中

　　　inet_ntoa相反

　　　continue回到while(1)

　　　select的第二个参数在select之前是作为参数传入 , select之后 改变了rfds的值后作为返回数据的指针返回出来

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

#define MAXBUF 1024

int main(int argc, char **argv)
{
        int sockfd, new_fd;
        socklen_t len;
        struct sockaddr_in my_addr, their_addr;
        unsigned int myport, lisnum;
        char buf[MAXBUF + 1];
        fd_set rfds;        //创建IO复用的容器
        struct timeval tv;    //select的超时时间
        int retval, maxfd = -1;

        if (argv[2])
                myport = atoi(argv[2]);        //输入端口
        else
                myport = 7838;
        if (argv[3])
                lisnum = atoi(argv[3]);        //输入最大连接数,也可以NULL
        else
                lisnum = 2;
        if ((sockfd = socket(PF_INET, SOCK_STREAM, 0)) == -1) {        //创建socket对象
                perror("socket");
                exit(EXIT_FAILURE);
        }

        bzero(&my_addr, sizeof(my_addr));    //置0
        my_addr.sin_family = PF_INET;        //设置本地信息
        my_addr.sin_port = htons(myport);
        if (argv[1])
            my_addr.sin_addr.s_addr = inet_addr(argv[1]);    //输入本地地址
        else
            my_addr.sin_addr.s_addr = INADDR_ANY;
        if (bind(sockfd, (struct sockaddr *) &my_addr, sizeof(struct sockaddr)) == -1) {    //绑定
           perror("bind");
           exit(EXIT_FAILURE);
        }
         if (listen(sockfd, lisnum) == -1) {        //监听
            perror("listen");
            exit(EXIT_FAILURE);
         }

         while (1) 
         {
               printf ("
----wait for new connect
");
            len = sizeof(struct sockaddr);
            if ((new_fd =accept(sockfd, (struct sockaddr *) &their_addr,&len)) == -1) {        //接受连接并保存对端信息
                perror("accept");
                 exit(errno);
            } else
                   printf("server: got connection from %s, port %d, socket %d
", 
                        inet_ntoa(their_addr.sin_addr),ntohs(their_addr.sin_port), new_fd);
            while (1) 
            {
                  FD_ZERO(&rfds);        //把IO复用的容器(rfds)置0
                   FD_SET(0, &rfds);    //把stdin加入到 rfds 
                FD_SET(new_fd, &rfds);    //把new_fd加入到 rfds 
                maxfd = new_fd;
                tv.tv_sec = 1;        //超时1秒
                tv.tv_usec = 0;
                retval = select(maxfd + 1, &rfds, NULL, NULL, &tv);        //阻塞 , 轮询加入到rfds里的fd ,超时后跳过阻塞往下执行
                if (retval == -1) 
                {
                    perror("select");
                    exit(EXIT_FAILURE);
                } else if (retval == 0) {    //如果select返回0证明没有数据更新
                         continue;    //跳过当前循环,强制开始下一次循环
                } 
                else
                {
                    if (FD_ISSET(0, &rfds))        //FD_ISSET 判断stdin是否有可读数据
                    {
                             bzero(buf, MAXBUF + 1);
                            fgets(buf, MAXBUF, stdin);    //获取stdin里的可读数据存入buf
                              if (!strncasecmp(buf, "quit", 4)) {
                                printf("i will quit!
");
                                 break;
                              }
                             len = send(new_fd, buf, strlen(buf) - 1, 0);    //send  buf
                            if (len > 0)
                                   printf ("send successful,%d byte send!
",len);
                              else {
                                  printf("send failure!");
                                break;
                            }
                    }
                    if (FD_ISSET(new_fd, &rfds)) //FD_ISSET 判断new_fd是否有可读数据
                    { 
                               bzero(buf, MAXBUF + 1);
                              len = recv(new_fd, buf, MAXBUF, 0);    //读取socket(new_fd)的可读数据
                               if (len > 0)
                                   printf ("recv success :'%s',%dbyte recv
", buf, len);
                               else
                            {
                                 if (len < 0)
                                    printf("recv failure
");
                                   else
                                {
                                      printf("the ohter one end ,quit
");
                                     break;
                                }
                               }
                       }
                 }
            }
            close(new_fd);
            printf("need othe connecdt (no->quit)");
            fflush(stdout);    //清空stdout的缓冲区
            bzero(buf, MAXBUF + 1);
            fgets(buf, MAXBUF, stdin);
            if (!strncasecmp(buf, "no", 2)) 
            {
                printf("quit!
");
                break;
            }
        }
        close(sockfd);
        return 0;
}

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

#define MAXBUF 1024
int main(int argc, char **argv)
{
    int sockfd, len;
    struct sockaddr_in dest;
    char buffer[MAXBUF + 1];
    fd_set rfds;
    struct timeval tv;
    int retval, maxfd = -1;

    if (argc != 3) 
    {
        printf("argv format errno,pls:
		%s IP port
",argv[0], argv[0]);
        exit(EXIT_FAILURE);
    }
    if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) 
    {
        perror("Socket");
        exit(EXIT_FAILURE);
    }

    bzero(&dest, sizeof(dest));
    dest.sin_family = AF_INET;
    dest.sin_port = htons(atoi(argv[2]));
    if (inet_aton(argv[1], (struct in_addr *) &dest.sin_addr.s_addr) == 0) 
    {
        perror(argv[1]);
        exit(EXIT_FAILURE);
    }

    if (connect(sockfd, (struct sockaddr *) &dest, sizeof(dest)) != 0) 
    {
        perror("Connect ");
        exit(EXIT_FAILURE);
    }

    printf("
get ready pls chat
");
    while (1) 
    {
        FD_ZERO(&rfds);
        FD_SET(0, &rfds);
        FD_SET(sockfd, &rfds);
        maxfd = sockfd;
        tv.tv_sec = 1;
        tv.tv_usec = 0;
        retval = select(maxfd + 1, &rfds, NULL, NULL, &tv);
        if (retval == -1) 
        {
            printf("select %s", strerror(errno));
            break;
        } 
        else if (retval == 0)
            continue;
        else
        {
            if (FD_ISSET(sockfd, &rfds)) 
            {
                bzero(buffer, MAXBUF + 1);
                len = recv(sockfd, buffer, MAXBUF, 0);
                if (len > 0)
                    printf ("recv message:'%s',%d byte recv
",buffer, len);
                else 
                {
                    if (len < 0)
                        printf ("message recv failure
");
                    else
                    {
                        printf("the othe quit ,quit
");
                        break;
                    }
                }
            }
            if (FD_ISSET(0, &rfds)) 
            {
                bzero(buffer, MAXBUF + 1);
                fgets(buffer, MAXBUF, stdin);
                if (!strncasecmp(buffer, "quit", 4)) {
                    printf("i will quit
");
                    break;
                }
                len = send(sockfd, buffer, strlen(buffer) - 1, 0);
                if (len < 0) {
                    printf ("message send failure");
                    break;
                } else
                    printf
                        ("send success,%d byte send
",len);
            }
        }
    }
    close(sockfd);
    return 0;
} 

 利用数组存放不确定数量的IO句柄fd判断其状态(数组全是-1,如果有句柄fd存放将改变状态(-1变成select的返回值),无数据时fd返回0,有数据时fd返回数据大小,而并非-1(error除外))

　　利用循环把数组里(要select的)的句柄加入到fd_set, 轮询过后再利用循环更新rfds

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

#define _BACKLOG_ 5 //监听队列里允许等待的最大值

//当不确定有多少需要重载fd_set的fd时,把fd存入一个数组,方便循环重载
int fds[20];//用来存放需要处理的IO事件

int creat_sock(char *ip,char *port)
{
    int sock = socket(AF_INET,SOCK_STREAM,0);
    if(sock < 0){
        perror("creat_sock error");
        exit(1);
    }

    struct sockaddr_in local;
    local.sin_family = AF_INET;
    local.sin_port = htons(atoi(port));
    local.sin_addr.s_addr = inet_addr(ip);
    
    if( bind(sock,(struct sockaddr*)&local,sizeof(local)) < 0){
        perror("bind");
        exit(2);
     }

    if(listen(sock,_BACKLOG_) < 0 ){
        perror("listen");
        exit(4);
     }

    return sock;
}

int main(int argc,char* argv[])
{
    if(argc != 3){
        printf("Please use : %s [ip] [port]
",argv[0]);
        exit(3);
    }
    int listen_sock = creat_sock(argv[1],argv[2]);    //创建socket对象

    size_t fds_num = sizeof(fds)/sizeof(fds[0]);    //获得数组长度
    size_t i = 0;
    for(;i < fds_num;++i)    //在socket里0也是句柄, 所以全部-1 , 以确定数组状态
    {
        fds[i] = -1;
    }
    
    int max_fd = listen_sock;    //确定最大fd    select时+1
    
    fd_set rset;    //创建rfds
    while(1)
    {        
        FD_ZERO(&rset);        //置0
        FD_SET(listen_sock,&rset);    //把本地fd (加入重载)rfds
        max_fd = listen_sock;
        //struct timeval timeout = {20 , 0};
        fds[0]=listen_sock;        //确定第一个fd是本地直接加入
        size_t i = 0;
        for(i=1;i < fds_num;++i)    //从第二个开始加入fd
        {
            if(fds[i] > 0 ){        //大于0说明有fd
                FD_SET(fds[i] ,&rset);    //把fd (加入重载)rfds
                if(max_fd < fds[i])    //冒泡算法,找出最大的fd
                {
                    max_fd = fds[i];
                }
            }
        }

        switch(select(max_fd+1,&rset,NULL,NULL,NULL))    //select最大fd+1
        {
            case -1:
                perror("select");
                break;
            case 0:
                printf("time out..
");
                break;
            default:
            {
                size_t i = 0;
                for(;i < fds_num;++i)
                {
                 //当为listen_socket事件就绪的时候，就表明有新的连接请求
                    if(FD_ISSET(fds[i],&rset) && fds[i] == listen_sock)        //判断数组里的第一个fd(本地fd)是否有数据
                    {
                        struct sockaddr_in client;
                        int accept_sock = accept(listen_sock,(struct sockaddr*)&client,sizeof(client));    //接受连接并保存对端信息
                        if(accept_sock < 0){
                            perror("accept");
                            exit(5);
                        }
                        //char * paddr=NULL;
                        //char * saddr=NULL;
                        //paddr=inet_ntoa(client.sin_addr);
                        //saddr=inet_ntoa(client.sin_addr);
                        printf("connect by a client, ip:%s port:%d
",inet_ntoa(client.sin_addr),ntohs(client.sin_port));

                        size_t i = 0;
                        for(;i < fds_num;++i)//将新接受的描述符存入集合中
                        {
                            if(fds[i] == -1){
                                fds[i] = accept_sock;
                                break;
                            }
                        }
                        if(i == fds_num)
                        {
                            close(accept_sock);
                        }
                    }
                    //普通请求
                    else if(FD_ISSET(fds[i],&rset) && (fds[i] > 0))
                    {
                        char buf[1024];
                        memset(buf,'',sizeof(buf));
                        ssize_t size = read(fds[i],buf,sizeof(buf)-1);
                        if(size < 0){
                            perror("read");
                            exit(6);
                        }else if(size == 0){
                            printf("client close..
");
                            close(fds[i]);
                            fds[i] = -1;
                        }else{
                            printf("client say: %s
",buf);
                        }
                        
                    }
                    else{}
                }
                
            }
            break;
        }
    }
    return 0;
}

---

9.IO复用的内核实现　　　　　　Linux应用层的阻塞都可能会被信号所中断(应用层的中断叫可中断睡眠状态) 

　　9.1 内核的实现其实是一个面向对象 步骤:

　　　　

　　面向对象三步骤:　(回顾04所描述的 , Linux一切皆文件(内核设计的核心之一,链表: 利用结构体里的函数指针针对不同的需求,进行不同的分配(设置函数指针指向驱动(实现需求的)函数) , 再把对象注册(加入)到管理链表的函数里使用)完成面向对象设计的思路)

　　　　注册对象:　内核里注册一个file_operations对象

　　　　分配对象:　把结构体里的函数指针分别指向对应的函数驱动(等同于赋值吧)

　　　　使用对象:　使用file提供的register(加入链表)函数, 把file_operations提交到file里

　　应用层要使用select,通过一系列的查找,找到file---->file_operations------->select(select其实是调用了poll的驱动函数)逐层查找

　　9.2: poll的实现和使用差不多(一般不会单独使用poll)　使用: https://blog.csdn.net/zhuxiaoping54532/article/details/51701549

　　　　　　　　　　　　　　　select 和 poll 和epoll的   区别: https://www.cnblogs.com/aspirant/p/9166944.html

　　9.3 epoll的实现流程和使用 (IO复用大多数情况都是使用epoll了)

　　　select和poll受限于fd(数量有1000就影响效率了,并不能满足高并发的服务器), epoll将事件抽象成event(不受限于fd)

　　epoll_even的结构:

struct epoll_event
{
    uint32_t events;   /* 事件的类型 */
    epoll_data_t data;    /* 事件的信息 */
} __attribute__ ((__packed__));

typedef union epoll_data
{
    void *ptr;
    int fd;
    uint32_t u32;
    uint64_t u64;
} epoll_data_t;

　　一样是面向对象三步骤:

　　　　创建epollfd对象

　　　　　　int epoll_create(int size)　//size = 监听事件的数量

　　　　　　返回值 epoll_fd  , epoll_ event

　　　　设置epollfd对象

　　　　　　创建epoll_event对象

　　　　　　　　struct epoll_event ep_ev　　

　　　　　　设置epoll_event对象

　　　　　　　　ep_ev.events=(EPOLLIN 输入事件)(EPOLLOUT 输出事件)...　　监听的事件类型,读取或者写入

　　　　　　　　ep_ev.events.fd=listen_sock　　监听句柄是否有事件产生

　　　　　　使用:epoll_event对象　https://www.cnblogs.com/Dream-Chaser/p/7401184.html

　　　　　　　　int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event)

　　　　　　　　epoll_ctl(epoll_fd, EPOLL_CTL_ADD, epoll_event, ep_ev)

　　　　使用epollfd对象
　　　　　　int epoll_wait(int epfd, struct epoll_event* events,int maxevents, int timeout); events用来做返回的

http://blog.sina.com.cn/s/blog_488531130100i706.html

大白话的讲就是, 创建epoll_fd容器,里面放的是一个个的epoll_event事件, 事件对listen_sock监听,如果listen_sock有对客户端传入
的数据进行读取(进而产生事件)则进行一系列的返回, 而epoll_wait进行轮询(就是监听)也有超时(和select作用一样), epoll_ctl的作用是把事件
加入到epoll_fd里
epoll使用的精髓　　https://www.cnblogs.com/fnlingnzb-learner/p/5835573.html

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

int creat_socket(char *ip,char* port)
{
    int sock = socket(AF_INET,SOCK_STREAM,0);
    if(sock < 0){
        perror("socket");
        exit(2);
    }

    //调用setsockopt使当server先断开时避免进入TIME_WAIT状态,
     将其属性设定为SO_REUSEADDR，使其地址信息可被重用
    int opt = 1;
    if(setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(opt)) < 0){
        perror("setsockopt");
        exit(3);
    }

    struct sockaddr_in local;

    local.sin_family = AF_INET;
    local.sin_port = htons(atoi(port));
    local.sin_addr.s_addr = inet_addr(ip);

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

    if(listen(sock,5) < 0){
        perror("listen");
        exit(5);
    }
    
    printf("listen and bind succeed
");

    return sock;
}

int set_noblock(int sock)
{
    int fl = fcntl(sock,F_GETFL);
    return fcntl(sock,F_SETFL,fl|O_NONBLOCK);
}

int main(int argc,char *argv[])
{
    if(argc != 3){
        printf("please use:%s [ip] [port]",argv[0]);
        exit(1);
    }
    int listen_sock = creat_socket(argv[1],argv[2]);    //创建socket

    int epoll_fd = epoll_create(256);                    //创建epoll_fd容器
    if(epoll_fd < 0){
        perror("epoll creat");
        exit(6);
    }

    struct epoll_event ep_ev;            //创建事件
    ep_ev.events = EPOLLIN;                //事件的类型 IN读取
    ep_ev.data.fd = listen_sock;        //产生事件的对象 listen_sock

    //添加关心的事件
    //把事件和对象追加到epoll_fd
    if(epoll_ctl(epoll_fd,EPOLL_CTL_ADD,listen_sock,&ep_ev) < 0){
        perror("epoll_ctl");
        exit(7);
    }

    struct epoll_event ready_ev[128];//申请空间来放就绪的事件。
    int maxnum = 128;
    int timeout = 1000;//设置超时时间，若为-1，则永久阻塞等待。
    int ret = 0;
    
    int done = 0;
    //把产生的事件放入ready_ev里,再循环处理每一个事件, 先判断事件是否为socket且是PEOLLIN, 如果是则把socket里的事件
    追加到epoll_fd中,退出当次循环,进行下一次循环. 其实就是把所以事件都当成普通IO进行处理,因为epoll_event里有fd所以可以使用
    recv read等读写函数
    while(!done){
                //阻塞: 轮询epoll_fd里的所有事件直到(fd对象)产生事件并返回事件数量,或者超时后返回0往下执行
                        产生的事件会存放到ready_ev里
        switch(ret = epoll_wait(epoll_fd,ready_ev,maxnum,timeout)){
            case -1:
                perror("epoll_wait");
                break;
            case 0:
                printf("time out...
");
                break;
            default://至少有一个事件就绪
            {
                int i = 0;
                for(;i < ret;++i){    //循环处理epoll_fd里的事件
                    //判断是否为监听套接字，是的话accept
                    int fd = ready_ev[i].data.fd; 
                    if((fd == listen_sock) && (ready_ev[i].events & EPOLLIN)){
                        struct sockaddr_in remote;
                        socklen_t len = sizeof(remote);

                        int accept_sock = accept(listen_sock,(struct sockaddr*)&remote,&len);
                        if(accept_sock < 0){
                            perror("accept");
                            continue;
                        }
                        printf("accept a client..[ip]: %s,[port]: %d
",inet_ntoa(remote.sin_addr),ntohs(remote.sin_port));
                        //将新的事件添加到epoll集合中
                        ep_ev.events = EPOLLIN | EPOLLET;
                        ep_ev.data.fd = accept_sock;

                        set_noblock(accept_sock);    //设置成非阻塞

                        if(epoll_ctl(epoll_fd,EPOLL_CTL_ADD,accept_sock,&ep_ev) < 0){
                            perror("epoll_ctl");
                            close(accept_sock);
                        }
                    }
                    else{//普通IO
                         if(ready_ev[i].events & EPOLLIN){
                             //申请空间同时存文件描述符和缓冲区地址

                             char buf[102400];
                             memset(buf,'',sizeof(buf));

                             ssize_t _s = recv(fd,buf,sizeof(buf)-1,0);
                             if(_s < 0){
                                 perror("recv");
                                 continue;
                             }else if(_s == 0){
                                 printf("remote close..
");
                                //远端关闭了，进行善后
                                 epoll_ctl(epoll_fd,EPOLL_CTL_DEL,fd,NULL);
                                 close(fd);
                             }else{
                                 //读取成功，输出数据
                                 printf("client# %s",buf);
                                 fflush(stdout);

                                 //将事件改写为关心事件，进行回写
                                 ep_ev.data.fd = fd;
                                 ep_ev.events = EPOLLOUT | EPOLLET;

                                 //在epoll实例中更改同一个事件
                                 epoll_ctl(epoll_fd,EPOLL_CTL_MOD,fd,&ep_ev);
                             }
                         }else if(ready_ev[i].events & EPOLLOUT){
                                 const char*msg = "HTTP/1.1 200 OK 

<h1> hi girl </h1>
";
                                 send(fd,msg,strlen(msg),0);
                                 epoll_ctl(epoll_fd,EPOLL_CTL_DEL,fd,NULL);
                                 close(fd);
                            }
                        }
                    }
                }
                break;
            
        }
    }
    close(listen_sock);
    return 0;
}

---

总结: IO复用是一种机制，一个进程可以监听多个描述符，一旦某个描述符就绪(读就绪和写就绪)，能够对程序进行相应的读写操作

　　目前支持I/O复用的系统调用有select,poll,pselect,epoll，本质上这些I/O复用技术是同步I/O技术。一般都是使用epoll的

　　与多进程和多线程相比，I/O复用技术的最大优势是系统开销小，系统不必创建进程/线程，也不必维护这些进程/线程，从而大大减小了系统的开销。

　　select(): 创建fd_set结构体对象rfds(这是一个保存文件描述符的文件数组) , FD_ZERO(&rfds)置空rfds , FD_SET(fd, &rfds)文件描述符加入到rfds, 

　　　　　　select(nfds+1, &rfds, NULL, NULL, &timeout);轮询监听 rfds 里的文件状态是否改变, 返回状态改变的fd的数量, 无则返回0 超时, error返回-1

　　　　　　FD_ISSET(fd, &rfds) 判断状态改变的fd是否是当前fd ,是则返回1 ,否则返回0 ,技巧:可以把fd放入一个数组通过下标 ,加入和判断

　　epoll():  把监听fd状态的改变 ,转变成监听事件的发生　　详细 https://www.cnblogs.com/fnlingnzb-learner/p/5835573.html

epoll_fd = epoll_create(size)　　　　//创建事件容器和其大小
struct epoll_event ep_ev;           //创建事件
ep_ev.events = EPOLLIN;             //事件的类型 　　如果发生IN读取,则统一做出对应处理
ep_ev.data.fd = fd;       　　　　　  //产生事件的对象 ,如果产生事件的是一个socket_fd, 接受连接accept()后把其转化成事件,并加入rfds里

struct epoll_event ready_ev[128];　　　　　　　　//申请空间来放就绪的事件。最大数不能超过创建epoll的大小

epoll_ctl(epoll_fd,EPOLL_CTL_ADD,fd,&ep_ev);　　//把fd和其事件类型追加到epoll_fd里

epoll_wait(epoll_fd,ready_ev,maxnum,timeout);　　//等待事件的产生，类似于select()调用 ,把产生的事件依次存入ready_ev里 ,用循环[i]依次处理就绪事件

关于ET、LT两种工作模式： LT：只要内核缓冲区有数据就一直通知(一直触发),直到读完缓冲区, 这种模式可靠,但低效率
　　　　　　　　　　　　　ET：只有状态发生变化才通知 ,只触发一次(文件描述符状态变化时),可能会导致数据读不完 ,这种模式不可靠 ,但高效率,
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　所以要自己实现一个能读取完整缓冲区的recv函数