1、基本概念
IO多路复用是指内核一旦发现进程指定的一个或者多个IO条件准备读取，它就通知该进程。IO多路复用适用如下场合：
（1）当客户处理多个描述字时（一般是交互式输入和网络套接口），必须使用I/O复用。
（2）当一个客户同时处理多个套接口时，而这种情况是可能的，但很少出现。
（3）如果一个TCP服务器既要处理监听套接口，又要处理已连接套接口，一般也要用到I/O复用。
（4）如果一个服务器即要处理TCP，又要处理UDP，一般要使用I/O复用。
（5）如果一个服务器要处理多个服务或多个协议，一般要使用I/O复用。
与多进程和多线程技术相比，I/O多路复用技术的最大优势是系统开销小，系统不必创建进程/线程，也不必维护这些进程/线程，从而大大减小了系统的开销。
2、select函数
该函数准许进程指示内核等待多个事件中的任何一个发送，并只在有一个或多个事件发生或经历一段指定的时间后才唤醒。函数原型如下：
#include <sys/select.h> #include <sys/time.h> int select(int maxfdp1,fd_set *readset,fd_set *writeset,fd_set *exceptset,const struct timeval *timeout)
返回值：就绪描述符的数目，超时返回0，出错返回-1
函数参数介绍如下：
（1）第一个参数maxfdp1指定待测试的描述字个数，它的值是待测试的最大描述字加1（因此把该参数命名为maxfdp1），描述字0、1、2...maxfdp1-1均将被测试。
因为文件描述符是从0开始的。
（2）中间的三个参数readset、writeset和exceptset指定我们要让内核测试读、写和异常条件的描述字。如果对某一个的条件不感兴趣，就可以把它设为空指针。struct fd_set可以理解为一个集合，这个集合中存放的是文件描述符，可通过以下四个宏进行设置：
void FD_ZERO(fd_set *fdset); //清空集合
void FD_SET(int fd, fd_set *fdset); //将一个给定的文件描述符加入集合之中
void FD_CLR(int fd, fd_set *fdset); //将一个给定的文件描述符从集合中删除
int FD_ISSET(int fd, fd_set *fdset); // 检查集合中指定的文件描述符是否可以读写
（3）timeout告知内核等待所指定描述字中的任何一个就绪可花多少时间。其timeval结构用于指定这段时间的秒数和微秒数。
struct timeval{
long tv_sec; //seconds
long tv_usec; //microseconds
};
这个参数有三种可能：
（1）阻塞：仅在有一个描述字准备好I/O时才返回。为此，把该参数设置为空指针NULL。
（2）等待固定时长：在有一个描述字准备好I/O时返回，但是不超过由该参数所指向的timeval结构中指定的秒数和微秒数。
（3）轮询：检查描述字后立即返回，这称为轮询。为此，该参数必须指向一个timeval结构，而且其中的定时器值必须为0。
原理图：
代码：
/* Socket learning */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <unistd.h>
#include <resolv.h>
#include <errno.h>
#include <fcntl.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/time.h>
#include "tcp_chats_server.h"
static server_context_st srv_ctx;
static int sock_set_noblock(int fd)
{
int flags;
if((flags = fcntl(fd, F_GETFL, 0)) < 0)
{
perror("fcntl");
return -1;
}
flags |= O_NONBLOCK;
if(fcntl(fd, F_SETFL, flags) < 0)
{
perror("fcntl");
return -1;
}
}
static int create_server_proc(uint32 ip, uint32 port)
{
int fd;
struct sockaddr_in server_addr;
/* 创建socket对象
* AF_INET：IPv4协议簇
* SOCK_STREAM：面向连接的流socket，默认tcp
*/
fd = socket(AF_INET, SOCK_STREAM, 0);
if(-1 == fd)
{
perror("socket");
exit(EXIT_FAILURE);
}
//sock_set_noblock(fd);
/*一个端口释放后会等待两分钟之后才能再被使用，SO_REUSEADDR是让端口释放后立即就可以被再次使用。*/
int reuse = 1;
if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse)) == -1)
{
return -1;
}
bzero(&server_addr, sizeof(struct sockaddr_in));
server_addr.sin_family = AF_INET;
server_addr.sin_addr.s_addr = ip;
server_addr.sin_port = htons(port);
/* 绑定本地IP与端口 */
if(-1 == bind(fd, (struct sockaddr *)&server_addr, sizeof(struct sockaddr)))
{
perror("bind");
exit(EXIT_FAILURE);
}
/* 监听网络 */
if(-1 == listen(fd, MAX_LISTEN_NUM))
{
perror("listen");
exit(EXIT_FAILURE);
}
return fd;
}
static int accept_client_proc(int server_fd)
{
struct sockaddr_in client_addr;
int client_fd = -1;
socklen_t len = sizeof(struct sockaddr);
printf("Accept client proc is called.\n");
client_fd = accept(server_fd, (struct sockaddr *)&client_addr, &len);
if(-1 == client_fd)
{
if(EAGAIN == errno)
{
//fprintf(stderr, "No client connections yet\n");
return -1;
}
else
{
fprintf(stderr, "accpet fail, error:%s\n", strerror(errno));
return -1;
}
}
fprintf(stdout, "Accept a new client: %s:%d\n",
inet_ntoa(client_addr.sin_addr), client_addr.sin_port);
//将新的连接描述符添加到数组中
int i = 0;
for(i = 0; i < MAX_CLI_NUM; i++)
{
if(srv_ctx.cli_fds[i] < 0)
{
srv_ctx.cli_fds[i] = client_fd;
srv_ctx.cli_cnt++;
break;
}
}
if(i == MAX_CLI_NUM)
{
fprintf(stderr, "Too many clients.\n");
return -1;
}
return 0;
}
static int handle_client_msg(int fd, char *buf)
{
assert(buf);
printf("Recv : fd(%d) %s\n", fd, buf);
write(fd, buf, strlen(buf) + 1);
return 0;
}
static void recv_client_msg(fd_set *prfds)
{
int i = 0, n = 0;
int client_fd = -1;
char buf[MAX_BUF_NUM] = {0};
for(i = 0; i <= srv_ctx.cli_cnt; i++)
{
client_fd = srv_ctx.cli_fds[i];
if(client_fd < 0)
{
continue;
}
/*判断客户端套接字是否有数据*/
if(FD_ISSET(client_fd, prfds))
{
n = read(client_fd, buf, MAX_BUF_NUM);
if(n <= 0)
{
/* n==0 表示读取完成，客户端关闭套接字 */
printf("close socket : %d\n", client_fd);
FD_CLR(client_fd, &srv_ctx.rfds);
close(client_fd);
srv_ctx.cli_fds[i] = -1;
continue;
}
handle_client_msg(client_fd, buf);
}
}
}
static void handle_client_proc(int server_fd)
{
int client_fd = -1;
int retval = 0;
fd_set *prfds = &srv_ctx.rfds;
struct timeval tv;
int i = 0;
while(1)
{
/* 每次调用select前都要重新设置文件描述符和时间，因为事件发生后，
* 文件描述符和时间都被内核修改啦
*/
FD_ZERO(prfds);
/* 添加监听套接字 */
FD_SET(server_fd, prfds);
srv_ctx.maxfd = server_fd;
tv.tv_sec = 30;
tv.tv_usec = 0;
/* 添加客户端套接字 */
for(i = 0; i < srv_ctx.cli_cnt; i++)
{
client_fd = srv_ctx.cli_fds[i];
/* 去除无效的客户端句柄 */
if(-1 != client_fd)
{
FD_SET(client_fd, prfds);
}
srv_ctx.maxfd = (client_fd > srv_ctx.maxfd ? client_fd:srv_ctx.maxfd);
}
/* 开始轮询接收处理服务端和客户端套接字 */
retval = select(srv_ctx.maxfd + 1, prfds, NULL, NULL, &tv);
if(-1 == retval)
{
fprintf(stderr, "Select error : %s\n", strerror(errno));
return;
}
if(0 == retval)
{
//fprintf(stdout, "Select is timeout\n");
continue;
}
if(FD_ISSET(server_fd, prfds))
{
/* 监听客户端请求 */
accept_client_proc(server_fd);
}
else
{
/* 接收处理客户端消息 */
recv_client_msg(prfds);
}
}
}
static int server_init(void)
{
memset(&srv_ctx, 0, sizeof(server_context_st));
int i = 0;
for(; i < MAX_CLI_NUM; i++)
{
srv_ctx.cli_fds[i] = -1;
}
return 0;
}
int main(int argc, char *argv[])
{
int fd_srv = -1;
uint32 ip, port;
/* 获取本机IP */
if(argv[1])
{
//将点分十进制字符串转换为网络顺序IP地址
ip = inet_addr(argv[1]);
}
else
{
//负责设置本机任意地址
ip = INADDR_ANY;
}
/* 获取监听端口 */
if(argv[2])
{
port = (uint32)atoi(argv[2]);
}
else
{
port = 10000;
}
server_init();
fd_srv = create_server_proc(ip, port);
while(1)
{
//accept_client_proc(fd_srv);
handle_client_proc(fd_srv);
}
close(fd_srv);
return 0;
}