《TCP/IP网络编程》阅读笔记--I/O复用
目录
1--基于I/O复用的服务器
2--select()函数
3--基于I/O复用的回声服务器端
4--send()和recv()函数的常用可选项
5--readv()和writev()函数
1--基于I/O复用的服务器
多进程服务器端具有以下缺点：当有多个客户端发起连接请求时，就会创建多个进程来分别处理客户端的请求，创建多个进程往往需要付出巨大的代价；
I/O复用的服务器端可以减少进程数，无论连接多少个客户端，提供服务的进程都只有 1 个；
2--select()函数
select() 函数可以将多个文件描述符集中到一起来统一监视，监视文件描述符可以视为监视 socket；集中多个文件描述符时需要按照接收、传输和异常三种情况进行区分；
select() 通过 fd_set 数组变量来执行监视操作，fd_set 中文件描述符（索引）对应的位（值）被设置为 1 时，表明该文件描述符是监视对象；
// 对 fd_set 数组的常用操作
FD_ZERO(fd_set* fd_set); // 将 fd_set 变量的所有位初始化为0
FD_SET(int fd, fd_set* fdset); // 在参数 fdset 指向的变量中注册文件描述符fd的信息
FD_CLR(int fd, fd_set* fdset); // 从参数 fdset 指向的变量中消除文件描述符fd的信息
FD_ISSET(int fd, fd_set* fdset); // 若参数 fdset 指向的变量中包含文件描述符fd的信息，则返回true
#include
#include
int select(int maxfd, fd_set* readset, fd_set* writeset, fd_set* exceptset, const struct timeval* timeout);
// 成功时返回大于 0 的值，值为发生事件的文件描述符数；失败时返回 -1；超时返回 0
// maxfd 表示监视对象文件描述符的数量
// readset 表示将所有关注“是否存在待读取数据”的文件描述符注册到fd_set型变量，并传递其地址值
// writeset 表示将所有关注“是否可传输无阻塞数据”的文件描述符注册到fd_set型变量，并传递其地址值
// exceptset 表示将所有关注“是否发生异常”的文件描述符注册到fd_set型变量，并传递其地址值
// timeout 表示调用 select() 函数后，为防止陷入无限阻塞的状态，传递超时信息 select() 函数只有在监视的文件描述符发生变化时才返回，如果未发生变化就会进入阻塞状态；通过指定超时事件可以防止无限阻塞的情况，即使文件描述符中未发生变化，当超过了指定事件，就会从函数中返回，返回值为 0；
当调用 select() 函数时，除了发生变化的文件描述符之外，所有原来值为 1 的位均会变为 0，因此可知值仍为 1 的文件描述符发生了变化；
// gcc select.c -o select
// ./select
#include
#include
#include
#include
#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变量
FD_SET(0, &reads); // 将文件描述符 0 对应的位设置为1，表示监视标准输入（文件描述符0对应标准输入stdin）
while(1){
temps = reads; // 记录初始值，新循环时重新初始化为初始值
timeout.tv_sec = 5; // 超时时间设置为 5s
timeout.tv_usec = 0;
result = select(1, &temps, 0, 0, &timeout); // 5s内监视是否有标准输入时间发生
if(result == -1){
puts("select() error!");
break;
}
else if(result == 0){ // 返回值为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;
}
3--基于I/O复用的回声服务器端
// gcc echo_selectserv.c -o echo_selectserv
// ./echo_selectserv 9190
#include
#include
#include
#include
#include
#include
#include
#include
#define BUF_SIZE 100
void error_handling(char *buf){
fputs(buf, stderr);
fputc('\n', stderr);
exit(1);
}
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 \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变量
FD_SET(serv_sock, &reads); // 监视 serv_sock
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){ // 服务器端socket有变化，执行受理连接请求
adr_sz = sizeof(clnt_adr);
clnt_sock = accept(serv_sock, (struct sockaddr*)&clnt_adr, &adr_sz);
FD_SET(clnt_sock, &reads); // 将客户端socket注册到fd_set变量中
if(fd_max < clnt_sock){
fd_max = clnt_sock;
}
printf("connected client: %d \n", clnt_sock);
}
else{ // 不是服务器端socket发生变化，表明有要接收的数据
str_len = read(i, buf, BUF_SIZE);
if(str_len == 0){ // 接收的是 EOF，表明要断开连接
FD_CLR(i, &reads);
close(i);
printf("closed client: %d \n", i);
}
else{ // 接收的是真实数据
write(i, buf, str_len); // 将接收到的数据返回客户端，实现回声功能
}
}
}
}
}
close(serv_sock);
return 0;
} 4--send()和recv()函数的常用可选项
#include
ssize_t send(int sockfd, const void* buf, size_t nbytes, int flags);
ssize_t recv(int sockfd, void* buf, size_t nbytes, int flags);
// flags 表示可选项信息 通常情况下，我们会将 send() 和 recv() 的可选项参数设置为 0，但其实际拥有以下可选项：
① MSG_OOB 表示用于传输带外数据（send、recv）
② MSG_PEEK 表示验证输入缓冲中是否存在接收的数据（recv）
③ MSG_DONTROUTE 表示数据传输过程中不参照路由表，在本地网络中寻找目的地（send）
④ MSG_DONTWAIT 表示调用 I/O 函数时不阻塞，用于使用非阻塞 I/O（send、recv）
⑤ MSG_WAITALL 表示防止函数返回，直到接收全部请求的字节数（recv）
MSG_OOB 用于发送带外数据的紧急消息，操作系统收到紧急消息时，将产生 SIGURG 信号，并调用注册的信号处理函数；
// gcc oob_recv.c -o oob_recv
// ./oob_recv 9190
#include
#include
#include
#include
#include
#include
#include
#include
#define BUF_SIZE 30
int acpt_sock;
int recv_sock;
void error_handling(char *message){
fputs(message, stderr);
fputc('\n', stderr);
exit(1);
}
void urg_handler(int signo){
int str_len;
char buf[BUF_SIZE];
str_len = recv(recv_sock, buf, sizeof(buf) - 1, MSG_OOB);
buf[str_len] = 0;
printf("Urgent message: %s \n", buf);
}
int main(int argc, char* argv[]){
struct sockaddr_in recv_adr, serv_adr;
int str_len, state;
socklen_t serv_adr_sz;
struct sigaction act;
char buf[BUF_SIZE];
if(argc != 2){
printf("Usage : %s \n", argv[0]);
exit(1);
}
act.sa_handler = urg_handler; //设置信号的处理函数
sigemptyset(&act.sa_mask);
act.sa_flags = 0;
acpt_sock = socket(PF_INET, SOCK_STREAM, 0);
memset(&recv_adr, 0, sizeof(recv_adr));
recv_adr.sin_family = AF_INET;
recv_adr.sin_addr.s_addr = htonl(INADDR_ANY);
recv_adr.sin_port = htons(atoi(argv[1]));
if(bind(acpt_sock, (struct sockaddr*) &recv_adr, sizeof(recv_adr)) == -1){
error_handling("bind() error");
}
listen(acpt_sock, 5);
serv_adr_sz = sizeof(serv_adr);
recv_sock = accept(acpt_sock, (struct sockaddr*)&serv_adr, &serv_adr_sz);
// getpid() 返回进程ID
// recv_sock发生SIGUGR信号，需要有确定的处理进程（假设创建了多个进程）来调用信号处理函数
// fcntl() 将 getpid() 返回的进程作为 SIGUGR 信号的处理进程
fcntl(recv_sock, F_SETOWN, getpid());
state = sigaction(SIGURG, &act, 0); // 发生SIGURG信号时，调用urg_handler()函数
while((str_len = recv(recv_sock, buf, sizeof(buf)-1, 0)) != 0){
if(str_len == -1){
continue;
}
buf[str_len] = 0;
puts(buf);
}
close(recv_sock);
close(acpt_sock);
return 0;
}
// gcc oob_send.c -o oob_send
// ./oob_send 127.0.0.1 9190
#include
#include
#include
#include
#include
#include
#define BUF_SIZE 30
void error_handling(char *message){
fputs(message, stderr);
fputc('\n', stderr);
exit(1);
}
int main(int argc, char *argv[]){
int sock;
struct sockaddr_in recv_adr;
if(argc != 3){
printf("Usage : %s \n", argv[0]);
exit(1);
}
sock = socket(PF_INET, SOCK_STREAM, 0);
memset(&recv_adr, 0, sizeof(recv_adr));
recv_adr.sin_family = AF_INET;
recv_adr.sin_addr.s_addr = inet_addr(argv[1]);
recv_adr.sin_port = htons(atoi(argv[2]));
if(connect(sock, (struct sockaddr*)&recv_adr, sizeof(recv_adr)) == -1){
error_handling("connect() error!");
}
write(sock, "123", strlen("123"));
send(sock, "4", strlen("4"), MSG_OOB); // 紧急传输数据
write(sock, "567", strlen("567"));
send(sock, "890", strlen("890"), MSG_OOB); // 紧急传输数据
close(sock);
return 0;
}
同时设置 MSG_PEEK 选项和 MSG_DONTWAIT 选项，可以验证输入缓冲中是否存在接收的数据，同时由于设置了 MSG_PEEK 选项，则调用 recv 函数时，即使读取了输入缓冲的数据也不会删除输入缓冲的数据（也就是说下一次读取时，还可以读到上一次读取的数据）；
// gcc peek_recv.c -o peek_recv
// ./peek_recv 9190
#include
#include
#include
#include
#include
#include
#define BUF_SIZE 30
void error_handling(char *message){
fputs(message, stderr);
fputc('\n', stderr);
exit(1);
}
int main(int argc, char* argv[]){
int acpt_sock, recv_sock;
struct sockaddr_in acpt_adr, recv_adr;
int str_len, state;
socklen_t recv_adr_sz;
char buf[BUF_SIZE];
if(argc != 2){
printf("Usage : %s \n", argv[0]);
exit(1);
}
acpt_sock = socket(PF_INET, SOCK_STREAM, 0);
memset(&acpt_adr, 0, sizeof(acpt_adr));
acpt_adr.sin_family = AF_INET;
acpt_adr.sin_addr.s_addr = htonl(INADDR_ANY);
acpt_adr.sin_port = htons(atoi(argv[1]));
if(bind(acpt_sock, (struct sockaddr*) &acpt_adr, sizeof(acpt_adr)) == -1){
error_handling("bind() error");
}
listen(acpt_sock, 5);
recv_adr_sz = sizeof(recv_adr);
recv_sock = accept(acpt_sock, (struct sockaddr*)&recv_adr, &recv_adr_sz);
while(1){
// 设置 MSG_PEEK|MSG_DONTWAIT 选项，即使不存在待读取的数据，也不会进入阻塞状态
// 假设存在待读取的数据，则读取且不删除输入缓冲的数据，因此下次仍可以读取
str_len = recv(recv_sock, buf, sizeof(buf) - 1, MSG_PEEK|MSG_DONTWAIT);
if(str_len > 0){
break;
}
}
buf[str_len] = 0;
printf("Buffering %d bytes: %s \n", str_len, buf);
// 读取上一次留在输入缓冲的数据
str_len = recv(recv_sock, buf, sizeof(buf) - 1, 0);
buf[str_len] = 0;
printf("Read again: %s \n", buf);
close(acpt_sock);
close(recv_sock);
return 0;
} // gcc peek_send.c -o peek_send
// ./peek_send 127.0.0.1 9190
#include
#include
#include
#include
#include
#include
void error_handling(char *message){
fputs(message, stderr);
fputc('\n', stderr);
exit(1);
}
int main(int argc, char *argv[]){
int sock;
struct sockaddr_in recv_adr;
if(argc != 3){
printf("Usage : %s \n", argv[0]);
exit(1);
}
sock = socket(PF_INET, SOCK_STREAM, 0);
memset(&recv_adr, 0, sizeof(recv_adr));
recv_adr.sin_family = AF_INET;
recv_adr.sin_addr.s_addr = inet_addr(argv[1]);
recv_adr.sin_port = htons(atoi(argv[2]));
if(connect(sock, (struct sockaddr*)&recv_adr, sizeof(recv_adr)) == -1){
error_handling("connect() error!");
}
write(sock, "123", strlen("123"));
close(sock);
return 0;
} 
5--readv()和writev()函数
readv() 和 writev() 函数对数据进行整合后，再进行读取和发送；即通过 writev() 函数可以将分散保存在多个缓冲中的数据一并发送，通过 readv() 函数可以由多个缓冲分别接收；
#include
ssize_t writev(int filedes, const struct iovec* iov, int iovcnt);
// 成功时返回发送的字节数，失败时返回 -1
// filedes 表示文件描述符
// iov 表示 iovec 结构体数组的地址值
// iovcnt 表示向第二个参数传递的数组长度
ssize_t readv(int filedes, const struct iovec* iov, int iovcnt);
// 成功时返回接收的字节数，失败时返回 -1
// iovec结构体
struct iovec{
void* iov_base; // 缓冲地址
size_t iov_len; // 缓冲大小
} 代码实例：
// gcc writev.c -o write
// ./write
#include
#include
int main(int argc, char* argv[]){
struct iovec vec[2];
char buf1[] = "ABCDEFG";
char buf2[] = "1234567";
int str_len;
vec[0].iov_base = buf1;
vec[0].iov_len = 3;
vec[1].iov_base = buf2;
vec[1].iov_len = 4;
str_len = writev(1, vec, 2); // 向文件描述符1写数据，即向标准输出写数据
puts("");
printf("Write bytes: %d \n", str_len);
return 0;
} 
// gcc readv.c -o readv
// ./readv
#include
#include
#define BUF_SIZE 100
int main(int argc, char *argv[]){
struct iovec vec[2];
char buf1[BUF_SIZE] = {0,};
char buf2[BUF_SIZE] = {0,};
int str_len;
vec[0].iov_base = buf1;
vec[0].iov_len = 5; // 设置最多保存5个字节
vec[1].iov_base = buf2;
vec[1].iov_len = BUF_SIZE;
str_len = readv(0, vec, 2); // 向标准输入（文件描述符0）读数据
printf("Read bytes: %d \n", str_len);
printf("First message: %s \n", buf1);
printf("Second message: %s \n", buf2);
return 0;
}
