I/O复用服务器

int select(int maxfd, fd_set *read_fds, fd_set *write_fds, fd_set *except_fds, struct timeval *timeout);
函数作用：调用select函数时，拥塞等待文件描述符事件的到来，如果超过了设定的时间，则不再等待，继续往下执行，不再阻塞。

参数：
　　maxfd：这是一个整数值，是指集合中所有文件描述符的范围，即所有文件描述符中的最大值加1，不能错！在Windows中这个参数值无所谓，可以设置不正确。
　　read_fds：指向fd_set结构的指针，这个集合中包括文件描述符，我们是要监视这些文件描述符的读变化的，即我们关心是否可以从这些文件中读取数据了，如果这个集合中有一个文件可读，select就会返回一个大于0的值，表示有文件可读。如果没有可读的文件，则根据timeout参数再判断是否超时，若超出timeout的时间，select返回0，若发生错误返回负值。可以传入NULL值，表示不关心任何文件的读变化。
　　write_fds：指向fd_set结构的指针，这个集合中应该包括文件描述符，我们是要监视这些文件描述符的写变化的，即我们关心是否可以向这些文件中写入数据了，如果这个集合中有一个文件可写，select就会返回         一个大于0的值，表示有文件可写。如果没有可写的文件，则根据timeout再判断是否超时，若超出timeout的时间，select返回0，若发生错误返回负值。可以传入NULL值，表示不关心任何文件的写变化。
　　except_fds：指向fd_set结构的指针，这个集合中应该包括文件描述符，我们是要监视这些文件描述符是否有异常。
　　timeout：用于设置select函数的超时时间，即告诉内核select等待多长时间之后就放弃等待。
　　　　NULL：一直阻塞，当监视的文件描述符集合中的某一个描述符发生变化才会返回结果并向下执行。
　　　　时间值为0：将select()函数置为非阻塞状态，执行select()后立即返回，无论文件描述符是否发生变化，只要检测完文件描述符集的状态，就立即返回。
　　　　时间值不为0：将select()函数的超时时间设为这个值，在超时时间内阻塞，超时后返回结果。在指定时间内，如果没有事件发生，则超时返回。

返回值：成功时返回fd的总数，超时时返回0，错失败时返回SOCKET_ERROR（-1）

fd_set是一个数组的宏定义，是一个unsigned long类型的数组，是一个socket集合。每一个数组元素都能与一打开的文件句柄(socket、文件、管道、设备等)建立联系，建立联系的工作由程序员完成，当调用select()时，由内核根据IO状态修改fd_set的内容，由此来通知执行了select()的进程哪个句柄可读。常用如下宏来对fd_set进行操作：

#define __NFDBITS (8 * sizeof(unsigned long))                       //每个ulong型可以表示多少个bit,
#define __FD_SETSIZE 1024                                                   //socket最大取值为1024
#define __FDSET_LONGS (__FD_SETSIZE/__NFDBITS)      //bitmap一共有1024个bit，共需要多少个unsigned long

typedef struct 
{
　　unsigned long fds_bits [__FDSET_LONGS];       //用unsigned long数组来表示bitmap
} __kernel_fd_set;
typedef __kernel_fd_set fd_set;

struct timeval
{ 
　　long tv_sec;             /*秒 */
　　long tv_usec;            /*微秒 */
}

//每个unsigned long为32位，可以表示32个bit。
//fd >> 5 即 fd / 32，找到对应的ulong下标i；fd & 31 即fd % 32，找到在ulong[i]内部的位置

#define __FD_ZERO(fdsetp) (memset (fdsetp, 0, sizeof (*(fd_set *)(fdsetp))))                                          //memset bitmap
#define __FD_SET(fd, fdsetp) (((fd_set *)(fdsetp))->fds_bits[(fd) >> 5] |= (1<<((fd) & 31)))                       //设置对应的bit
#define __FD_CLR(fd, fdsetp) (((fd_set *)(fdsetp))->fds_bits[(fd) >> 5] &= ~(1<<((fd) & 31)))                   //清除对应的bit
#define __FD_ISSET(fd, fdsetp) ((((fd_set *)(fdsetp))->fds_bits[(fd) >> 5] & (1<<((fd) & 31))) != 0)          //判断对应的bit是否为1

FD_ZERO(fd_set *fdset);                 //把fd_set队列初始为空，即把fd_set类型变量的所有位都设为 0;
FD_SET(int fd, fd_set *fdset);          //把套接字fd添加到fdset中，即使用FD_SET将变量的某一位置位;
FD_CLR(int fd, fd_set *fdset);         //从sfdet中删除套接字fd，即手动清除某个位时可以使用 FD_CLR;
FD_ISSET(int fd, fd_set *fdset);      //检查套接字fd是否存在与fdset中，即使用 FD_ISSET来测试某个位是否被置位;

需要说明一点，在内核中，socket对应struct socket结构，但在返回给用户空间之前，内核做了一个关联：调用get_unused_fd_flags从当前进程中获取一个可用的文件描述符fd ，将struct socket结构关联到该fd，并返回fd给用户空间。所以在用户空间中，socket为文件描述符。另外，进程可以打开的文件数是有限制的，为1024，故socket的取值小于1024。

#include <stdio.h>
#include <unistd.h>
#include <sys/time.h>
#include <sys/select.h>
#define BUF_SIZE 30
 
int main(int argc, char *argv[])
{
    fd_set reads, temps;
    int result, str_len;
    char buf[BUF_SIZE];
    struct timeval timeout;
 
    FD_ZERO(&reads);
    FD_SET(0, &reads); // 0 is standard input(console)
 
    /*
    timeout.tv_sec=5;
    timeout.tv_usec=5000;
    */
 
    while (1)
    {
        temps = reads;
        timeout.tv_sec = 5;
        timeout.tv_usec = 0;
        result = select(1, &temps, 0, 0, &timeout);
        if (result == -1)
        {
            puts("select() error!");
            break;
        }
        else if (result == 0)
        {
            puts("Time-out!");
        }
        else
        {
            if (FD_ISSET(0, &temps))
            {
                str_len = read(0, buf, BUF_SIZE);
                buf[str_len] = 0;
                printf("message from console: %s", buf);
            }
        }
    }
    return 0;
}

# gcc select.c -o select
# ./select
Hi
message from console: Hi
Hello
message from console: Hello
Time-out!
Time-out!
Good Bye
message from console: Good Bye
Time-out!

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <sys/select.h>
 
#define BUF_SIZE 100
void error_handling(char *buf);
 
int main(int argc, char *argv[])
{
    int serv_sock, clnt_sock;
    struct sockaddr_in serv_adr, clnt_adr;
    struct timeval timeout;
    fd_set reads, cpy_reads;
 
    socklen_t adr_sz;
    int fd_max, str_len, fd_num, i;
    char buf[BUF_SIZE];
    if (argc != 2) {
        printf("Usage : %s <port>\n", argv[0]);
        exit(1);
    }
 
    serv_sock = socket(PF_INET, SOCK_STREAM, 0);
    memset(&serv_adr, 0, sizeof(serv_adr));
    serv_adr.sin_family = AF_INET;
    serv_adr.sin_addr.s_addr = htonl(INADDR_ANY);
    serv_adr.sin_port = htons(atoi(argv[1]));
 
    if (bind(serv_sock, (struct sockaddr *)&serv_adr, sizeof(serv_adr)) == -1)
        error_handling("bind() error");
    if (listen(serv_sock, 5) == -1)
        error_handling("listen() error");
 
    FD_ZERO(&reads);
    FD_SET(serv_sock, &reads);
    fd_max = serv_sock;
 
    while (1)
    {
        cpy_reads = reads;
        timeout.tv_sec = 5;
        timeout.tv_usec = 5000;
 
        if ((fd_num = select(fd_max + 1, &cpy_reads, 0, 0, &timeout)) == -1)
            break;
        if (fd_num == 0)
            continue;
 
        for (i = 0; i < fd_max + 1; i++)
        {
            if (FD_ISSET(i, &cpy_reads))
            {
                if (i == serv_sock) // connection request!
                {
                    adr_sz = sizeof(clnt_adr);
                    clnt_sock =
                        accept(serv_sock, (struct sockaddr *)&clnt_adr, &adr_sz);
                    FD_SET(clnt_sock, &reads);
                    if (fd_max < clnt_sock)
                        fd_max = clnt_sock;
                    printf("connected client: %d \n", clnt_sock);
                }
                else // read message!
                {
                    str_len = read(i, buf, BUF_SIZE);
                    if (str_len == 0) // close request!
                    {
                        FD_CLR(i, &reads);
                        close(i);
                        printf("closed client: %d \n", i);
                    }
                    else
                    {
                        write(i, buf, str_len); // echo!
                    }
                }
            }
        }
    }
    close(serv_sock);
    return 0;
}
 
void error_handling(char *buf)
{
    fputs(buf, stderr);
    fputc(‘\n‘, stderr);
    exit(1);
}

# gcc echo_selectserv.c -o echo_selectserv
# ./echo_selectserv 8500
connected client: 4
connected client: 5
closed client: 4
closed client: 5

# ./echo_client 127.0.0.1 8500
Connected...........
Input message(Q to quit): Hello world!
Message from server: Hello world!
Input message(Q to quit): Apple
Message from server: Apple
Input message(Q to quit): Banana
Message from server: Banana
Input message(Q to quit): q

# ./echo_client 127.0.0.1 8500
Connected...........
Input message(Q to quit): Java
Message from server: Java
Input message(Q to quit): Python
Message from server: Python
Input message(Q to quit): Golang
Message from server: Golang
Input message(Q to quit): q