I/O模型：
- 阻塞型I/O
- 非阻塞型I/O
- 信号驱动式I/O
- 异步I/O
- I/O复用
阻塞型I/O
默认情况下，所有套接字都是阻塞的。
非阻塞型I/O
进程把一个套接字设置成非阻塞是在通知内核：当所请求的I/O操作非的把本进程置于休眠状态时才能完成，不要把本进程置于休眠状态，而是返回一个错误（后面会进行讲解）
I/O复用
调用select或poll，阻塞在这两个系统调用中的某一个之上，而不是阻塞在真正的I/O系统调用上
传统的多线程模式下也可以进行操作，但是多线程是以CPU为基础的，要进行线程切换，因此在单线程模式下找一种办法来处理（当客户A发送消息时，客户B发送的消息会被放在AMD，不会丢失）
select函数
该函数允许进程指示内核等待多个事件中的任何一个发生，并只有在有一个或多个事件发生或经历一段指定的时间后才唤醒他
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
int select(int nfds, fd_set *readfds, fd_set *writefds,fd_set *exceptfds, struct timeval *timeout);
void FD_CLR(int fd, fd_set *set);
int FD_ISSET(int fd, fd_set *set);
void FD_SET(int fd, fd_set *set);
void FD_ZERO(fd_set *set);
参数分析
- nfds：最大文件描述符
在设计之初，内核就自定义了1024个描述符（可见后面的select的最大描述符数），可以用FD_SETSIZE标识，在程序运行的时候，每一个文件描述符都有随机的编号，nfds就是最大的一个 - struct timeval *timeout：告知内核等待所指定描述符中的任何一个就绪可花多长时间，其timeval结构用于指定这段时间的秒数和微秒数
struct timeval { long tv_sec; /* seconds */ long tv_usec; /* microseconds */ }; /* * 永远等待下去：参数为空 * 等待一段固定时间 * 根本不等待：检查描述符后立即返回，轮询，为此应该返回一个timeval结构 */ - 读/写/异常集—fd_set *：当客户端要对服务端进行信息传递时，让内核测试读，写和异常条件的描述符。select函数修改由指针readset，writeset，exceptset所指向的描述符集，因而这三个参数都是值-结果参数，调用该函数时，我们知道所有关心的描述符的值，该函数返回时，结果将知识哪些描述符已就绪。该函数返回后，我们使用FD_ISSET宏类测试fd_set数据类型中的描述符。描述符集内任何与未就绪描述符对应的位返回时均清成0。为此，每次重新调用select函数时，我们都得在此把所有描述符集内所关心的位均置为1
/* void FD_CLR(int fd, fd_set *set); int FD_ISSET(int fd, fd_set *set); void FD_SET(int fd, fd_set *set); void FD_ZERO(fd_set *set); */ for (int i = 0; i < n; i++) { fds[i] = accept(...); // 把所有客户的文件描述符放入一个数组先 if (fds[i] > max) { max = fds[i]; // 求出最大文件描述符 } } while (1) { FD_ZERO(&rset); for (int i = 0; i < n; i++) { FD_SET(fds[i], &rset); // 让内核查看是否可读，可读在rset中文件描述符为1 } }
描述符就绪条件
select的最大描述符数
在早些时候，大多数应用程序不会用到那么许多描述符。当初设计select时，操作系统通常对每个进程可用的描述符数设置了上限，select就使用相同的上限值。然而当今的unix版本允许每个进程使用事实上无限数目的描述符（仅仅受限于内存总量和管理性限制）
选择BDS/OS已改变了内核实现以允许更大的描述符集，并定义了四个新的FD_XXX宏用于定义动态分配并操纵这样的描述符集。然而从移植性来看，使用大描述符需要小心。
str_cli函数
此版本在于当套接字上发生某些事情的时候，客户可能阻塞于fgets调用，新版本改为阻塞于select，或是等待标准输入可读，或是等待套接字可读。
- 如果对端TCP发送数据，那么该套接字变成可读，并且read返回一个大于0的值
- 如果对端TCP发送一个FIN（对端终止进程），那么该套接字变成可读，并且read返回
- 如果对端TCP发送一个RST（对端主机崩溃后重新启动），那么该套接字变为可读，并且read返回-1，而error中含有确切的错误码
#define MAXLINE 100
void str_cli(FILE* fp, int sockfd) {
int maxfdp1;
fd_set rset;
char sendline[MAXLINE], recvline[MAXLINE];
FD_ZERO(&rset);
for(;;) {
FD_SET(fileno(fp), &rset);
FD_SET(sockfd, &rset);
maxfdp1 = max(fileno(fp), sockfd) + 1;
select(maxfdp1, &rset, NULL, NULL, NULL);
if (FD_ISSET(sockfd, &rset)) {
if (read(sockfd, recvline, MAXLINE) == 0) {
perror("read failed");
}
fputs(recvline, stout);
}
if (FD_ISSET(fileno(fp), &rset)) {
if (fgets(sendline, MAXLINE, fp) == NULL) {
return;
}
write(sockfd, sendline, strlen(sendline));
}
}
}
但是有时候不能忽略一个问题！RTT：round-trip time往返时间，加上服务器的处理时间，这是最理想的状态。可是在数据传输的时候。
可是这个是单进程，传输是进行管道传输的，是一个通道！可是在函数中当写完这个请求后，连接就立即关闭了？？？可是管道里面还要其他的请求和应答，而main函数随后终止。因此，在批量方式下，标准输入中的EOF并不意味着我们同时也完成了从套接字的读入，可能仍然有请求在去往服务器的路上，或者仍有应答在返回客户的路上。
这个时候便要用到半关闭（shutdown）：也就是说，我们想给服务器发送一个FIN，告诉他我们已经完成了数据传送，但是仍然保持着套接字描述符打开以便读取。
来看看shutdown半关闭
close函数有两个限制，都可用shutdown来解决
- close把描述符的引用计数减1，仅在该计数变为0时才关闭套接字，使用shutdown可以不管引用计数就激发TCP的正常连接序列
- close终止代码读和写两个分析的数据传送，既然TCP是全双工的，有时候我们需要告知对端我们已经完成了数据发送，即使对端仍有数据要发送给我们。这就是典型的str_cli函数在批量输入发送时候的情况
#include <sys/socket.h>
int shutdown(int sockfd, int howto);
// shutdown主要依赖于howto的参数
// SHUT_RD：关闭连接的这一半，套接字中不再有数据可用接收
// SHUT_WR：关闭连接的写这一半，套接字中不再有数据可用写
// SHUT_RDWR:连接的读半部和写半部都关闭，这和调用两次shutdown等效，第一次调用SHUT_RD，第二次调用SHUT_WR
下面来看看完整的str_cli代码
#define MAXLINE 100
void str_cli(FILE* fp, int sockfd) {
// 初始化sedineof为0，只要该标志为0，每次在主循环中我们总是select标志输入的可读性
int maxfdp1, stdineof;
fd_set rset;
char buf[MAXSIZE];
int n;
stdineof = 0;
FD_ZERO(&rset);
for(;;) {
if (stdineof== 0)
FD_SET(fileno(fp), &rset);
FD_SET(sockfd, &rset);
maxfdp1 = max(fileno(fp), sockfd) + 1;
select(maxfdp1, &rset, NULL, NULL, NULL);
if (FD_ISSET(sockfd, &rset)) {
if (read(sockfd, recvline, MAXLINE) == 0) {
if (stdineof == 1) return;
else perror("failed");
}
write(fileno(stdout), buf, n);
}
if (FD_ISSET(fileno(fp), &rset)) {
// 当我们在标准输入上碰到EOF时，我们把新标志stdineof设置为1，并且把第二个参数改成SHUT_WR，read和write对缓冲区进行操作而不是文本
if (read(fileno(fp), recvline, MAXLINE) == 0) {
stdineof = 1;
shutdown(sockfd, SHUT_WR); // send FIN
FD_CLR(fileno(fp), &rset);
continue;
}
write(sockfd, buf, n);
}
}
}
接下来服务端代码（注释已经详尽）
#include <iostream>
#include <sys/socket.h>
#include <sys/types.h>
#include <stdlib.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <sys/time.h>
#define SERVER_PORT 3670
#define SERVER_IP "127.0.0.1"
int main(void) {
int sockfd, confd;
int client[FD_SETSIZE]; // 1024
char buf[BUFSIZ]; // default
fd_set rset, allset;
struct sockaddr_in server_addr, client_addr;
int i, j, maxi, maxfd, neardy, n;
socklen_t client_addrlen;
sockfd = socket(AF_INET, SOCK_STREAM, 0);
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(SERVER_PORT);
server_addr.sin_addr.s_addr = inet_addr(SERVER_IP);
bind(sockfd, (struct sockaddr*)&server_addr, sizeof(server_addr));
listen(sockfd, 4);
// 此时监听描述符为最大文件描述符
maxfd = sockfd;
// 设置一个数组，全部初始化为-1，当有已连接描述符时把描述符按顺序加入
maxi = -1;
for (i = 0; i < FD_SETSIZE; i++) {
client[i] = -1;
}
FD_ZERO(&allset);
// 利用select的唯一监听描述符这一前提初始化我们的数据结构
FD_SET(sockfd, &allset);
while(1) {
// 获得上一步的io文件描述符
rset = allset;
// 等待一个连接
neardy = select(maxfd+1, &rset, NULL, NULL, NULL);
// 连接失败
if (neardy < 0) {
perror("select error");
}
// 查看监听描述符是否在可读文件描述符中，即查看是否有新的客户连接
if (FD_ISSET(sockfd, &rset)) {
client_addrlen = sizeof(client_addr);
// 和客户端连接并获得套接字
confd = accept(sockfd, (struct sockaddr*)&client_addr, &client_addrlen);
printf("received from %s at PORT %d\n", inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));
// 当有已连接描述符时把描述符按顺序加入，按顺序！
for (i = 0; i < FD_SETSIZE; i++) {
if (client[i] < 0) {
client[i] = confd;
break;
}
}
// FD_SETSIZE只有1024个，当超过最大限制，会报错
if (i == FD_SETSIZE) {
fputs("too many clients\n", stderr);
exit(1);
}
// 同时把该已连接描述符加入到集合中
FD_SET(confd, &allset);
// 判断最大文件描述符
if (confd > maxfd) {
maxfd = confd;
}
// 判断最大文件描述符在client中的位置
if (i > maxi) {
maxi = i;
}
// 没有多余的可读的描述符
if (--neardy == 0) {
continue;
}
}
// 遍历maxi检查所有的客户端的数据，所有的io都由这个进行！！！
for (i = 0; i < maxi; i++) {
if (client[i] < 0) {
continue;
}
// 查看该描述符是否在rset中
if (FD_ISSET(client[i], &rset)) {
// 如果连接关闭了
if (n = read(client[i], buf, sizeof(buf)) == 0) {
close(client[i]);
FD_CLR(client[i], &allset);
client[i] = -1;
}
else if (n > 0) {
bzero(buf, BUFSIZ);
for (j = 0; j < n; j++) {
buf[j] = toupper(buf[j]);
}
sleep(10);
write(client[i], buf, n);
}
}
else if (--neardy == 0) {
break;
}
}
}
close(sockfd);
return 0;
}
pselect函数
pselect是由于POSIX发明的，如今有很多unix变种支持他，我们仅做了解
#include <sys/select.h>
int pselect(int nfds, fd_set *readfds, fd_set *writefds,fd_set *exceptfds, const struct timespec *timeout,const sigset_t *sigmask);
相对于select改变的地方
- pselect使用timespec结构，而不是timeval结构
struct timespec { long tv_sec; /* seconds */ long tv_nsec; /* nanoseconds，支持纳秒，老结构支持微秒 */ }; - pselect函数增加了第六参数，一个指向信号掩码的指针，该参数允许程序先禁止递交某种信号，再测试由这些当前被禁止信号的信号处理函数设置的全局变量，然后调用pselect，告诉他重新设置信号掩码
poll函数
#include <poll.h>
int poll(struct pollfd *fds, nfds_t nfds, int timeout);
参数分析：
- struct pollfd *fds：指向一个结构狐族第一个元素的指针，每个数组元素都是一个plllfd结构
struct pollfd { int fd; /* file descriptor */ short events; /* 发送的事件 */ short revents; /* 返回的事件 */ }; - nfds_t nfds：结构体数组的元素个数
- timeout：时间限制
poll相对于select的优缺点：
-
文件描述符可以自定义的修改，比如1024修改成5000
// 查看 cat /proc/sys/fs/file-max // 如果有需要，修改配置 sudo vi /etc/security/limits.conf // 在文件尾写入以下配置，soft软限制，hard硬限制 * soft nofile 65536 * hard nofile 100000 -
select的监听，返回集合是一个集合，poll把题目分开了
-
自定义的文件描述符数组，搜索范围减小了
服务器代码
#include <sys/socket.h>
#include <sys/types.h>
#include <arpa/inet.h>
#include <iostream>
#include <string.h>
#include <poll.h>
#include <unistd.h>
#define OPEN_MAX 1024
#define SER_PORT 3000
#define SER_IP "127.0.0.1"
int main(void) {
int i, maxi, listenfd, connfd, sockfd;
int neardy;
ssize_t n;
char buf[BUFSIZ];
socklen_t clilen;
struct pollfd client[OPEN_MAX];
struct sockaddr_in cliaddr, servaddr;
listenfd = socket(AF_INET, SOCK_STREAM, 0);
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(SER_PORT);
servaddr.sin_addr.s_addr = inet_addr(SER_IP);
bind(listenfd, (struct sockaddr*)&servaddr, sizeof(servaddr));
listen(listenfd, 128);
client[0].fd = listenfd;
client[0].events = POLLIN;
for (i=1; i < OPEN_MAX; i++) {
client[i].fd = -1;
}
maxi = 0;
for(;;) {
neardy = poll(client, maxi+1, -1);
if (client[0].revents & POLLIN) {
clilen = sizeof(cliaddr);
connfd = accept(listenfd, (struct sockaddr*)&cliaddr, &clilen);
for (i = 1; i < OPEN_MAX; i++) {
if (client[i].fd < 0) {
client[i].fd = connfd;
break;
}
}
if (i == OPEN_MAX) {
perror("faile");
}
client[i].events = connfd;
if (i > maxi) {
maxi = i;
}
if (--neardy == 0) {
continue;
}
}
for (i = 1; i < maxi; i++) {
if (sockfd = client[i].fd < 0) {
continue;
}
if (client[i].revents & POLLIN) {
if (n = read(client[i].fd, buf, BUFSIZ) < 0) {
if (errno == ECONNRESET) {
close(sockfd);
client[i].fd = -1;
}
else {
perror("fail");
}
}
else if (n == 0) {
close(sockfd);
client[i].fd = -1;
}
else {
write(sockfd, buf, n);
}
if (--neardy == 0) {
break;
}
}
}
}
return 0;
}
