网络io与select
我们知道网络IO模型一共有5种，这里我们主要讨论同步IO和select多路复用的情况。
我们先从一个简单的TCP服务器的代码出发，来讨论一下这个是怎么实现的。
一个十分简单的TCP服务器
一个简单的TCP的服务器的建立流程是这样
- 建立SOCKET
- 绑定端口
- 监听
- 接受连接
- 接受消息
- 发送消息
- 关闭连接
#include<stdio.h>
#include<sys/socket.h>
#include<sys/types.h>
#include<netinet/in.h>
#include<fcntl.h>
#include <unistd.h>
#define BUFFER_LENGTH 128
int main()
{
//socket有两个参数，第一个参数指定我们要使用IPV4，还是IPV6，第二个参数表明我们要使用套接字类型，这里我们使用的是流格式的套接字，第三个参数就是我们需要使用传输协议
//这里使用0，表示让系统自动推导我们需要使用的传输协议。
int listenfd= socket(AF_INET,SOCK_STREAM,0);
//如果返回值为-1，说明我们创建SOCKET失败，直接返回。
if (listenfd==-1)
{
return -1;
}
//我们需要绑定的信息
struct sockaddr_in serveraddr;
//使用IPV4
serveraddr.sin_family=AF_INET;
//我们需要绑定的IP地址，INADDR_ANY 就是0.0.0.0 ，就是所有网卡的所有IP段都可以连接到我们的创建的TCP服务器上。
serveraddr.sin_addr.s_addr=htonl(INADDR_ANY);
//我们需要绑定的端口，这里我们绑定的端口为9999
serveraddr.sin_port=htons(9999);
//第一个参数我们创建的套接字，第二个是我们填写的绑定信息，最后是我们的绑定信息结构体的大小。
if (-1==bind(listenfd,(const sockaddr*)&serveraddr,sizeof(serveraddr)))
{
return -2;
}
//监听我们创建的套接字，请求的队列数量，这里我们填写为10个
listen(listenfd,10);
//定义客户端的socket
struct sockaddr_in client;
//客户端结构体的长度
socklen_t len=sizeof(client);
//等待接受连接
//第一个参数服务器的套接字，第二个接收到的客户端的socket，第三个函数就是结构体的长度
int clientfd=accept(listenfd,(struct sockaddr*)&client,&len);
//接受的缓冲区大小
unsigned char buffer[BUFFER_LENGTH]={0};
//收函数
//第一个参数客户端的套接字，第二个参数，接受的缓冲区，第三个参数缓冲区的大小，第4个参数接收到的字节数
int ret = recv(clientfd,buffer,BUFFER_LENGTH,0);
if (ret==0)
{
close(clientfd);
}
printf("buffer: %s , ret : %d\n",buffer,ret);
//发函数
//第一个参数客户端的套接字，第二个参数，发送的缓冲区，第三个参数发送的字节数，第4个参数实际发送的字节数
ret = send(clientfd,buffer,ret,0);
}
上面的代码已经把每个函数的参数的作用，还有 参数的意义都已经注释上了，
运行一下上面的代码，并使用我们的网络调试助手，发现我们的客户端已经可以收发数据了。
现在就遇到了一个问题，如果我们想一直接受和发送数据，我们需要做什么处理那？
可能大多数人都可以想到，我们添加 一个while循环的就可以一直接受数据了，因此我们改变一下我们的代码。
让它可以一直收发数据，知道我们的客户端退出为止。
#include<stdio.h>
#include<sys/socket.h>
#include<sys/types.h>
#include<netinet/in.h>
#include<fcntl.h>
#include <unistd.h>
#define BUFFER_LENGTH 128
int main()
{
//socket有两个参数，第一个参数指定我们要使用IPV4，还是IPV6，第二个参数表明我们要使用套接字类型，这里我们使用的是流格式的套接字，第三个参数就是我们需要使用传输协议
//这里使用0，表示让系统自动推导我们需要使用的传输协议。
int listenfd= socket(AF_INET,SOCK_STREAM,0);
//如果返回值为-1，说明我们创建SOCKET失败，直接返回。
if (listenfd==-1)
{
return -1;
}
//我们需要绑定的信息
struct sockaddr_in serveraddr;
//使用IPV4
serveraddr.sin_family=AF_INET;
//我们需要绑定的IP地址，INADDR_ANY 就是0.0.0.0 ，就是所有网卡的所有IP段都可以连接到我们的创建的TCP服务器上。
serveraddr.sin_addr.s_addr=htonl(INADDR_ANY);
//我们需要绑定的端口，这里我们绑定的端口为9999
serveraddr.sin_port=htons(9999);
//第一个参数我们创建的套接字，第二个是我们填写的绑定信息，最后是我们的绑定信息结构体的大小。
if (-1==bind(listenfd,(const sockaddr*)&serveraddr,sizeof(serveraddr)))
{
return -2;
}
//监听我们创建的套接字，请求的队列数量，这里我们填写为10个
listen(listenfd,10);
//定义客户端的socket
struct sockaddr_in client;
//客户端结构体的长度
socklen_t len=sizeof(client);
//等待接受连接
//第一个参数服务器的套接字，第二个接收到的客户端的socket，第三个函数就是结构体的长度
int clientfd=accept(listenfd,(struct sockaddr*)&client,&len);
//接受的缓冲区大小
unsigned char buffer[BUFFER_LENGTH]={0};
while (1)
{
//收函数
//第一个参数客户端的套接字，第二个参数，接受的缓冲区，第三个参数缓冲区的大小，第4个参数接收到的字节数
int ret = recv(clientfd,buffer,BUFFER_LENGTH,0);
if (ret<=0)
{
close(clientfd);
break;
}
printf("buffer: %s , ret : %d\n",buffer,ret);
//发函数
//第一个参数客户端的套接字，第二个参数，发送的缓冲区，第三个参数发送的字节数，第4个参数实际发送的字节数
ret = send(clientfd,buffer,ret,0);
}
return 0;
}
这样我们就达到了我们的要求，那么还有新的问题，就是我创建一个TCP server不能只使用一个。
下面就是如果我这个TCPserver想要连接多个客户端我应该怎么去做？
有两个可行的方案 ，供我们使用:
- 多线程、多进程的方式
- select，poll,epoll多路复用的方式。
我们首先看一下第一种的方式
多进程的方式，创建一个服务器，实现一个TCP 服务器可以连接多个TCP 客户端
#include<stdio.h>
#include<sys/socket.h>
#include<sys/types.h>
#include<netinet/in.h>
#include<fcntl.h>
#include <unistd.h>
#define BUFFER_LENGTH 128
int main()
{
unsigned char buffer[BUFFER_LENGTH]={0};
//socket有两个参数，第一个参数指定我们要使用IPV4，还是IPV6，第二个参数表明我们要使用套接字类型，这里我们使用的是流格式的套接字，第三个参数就是我们需要使用传输协议
//这里使用0，表示让系统自动推导我们需要使用的传输协议。
int listenfd= socket(AF_INET,SOCK_STREAM,0);
//如果返回值为-1，说明我们创建SOCKET失败，直接返回。
if (listenfd==-1)
{
return -1;
}
//我们需要绑定的信息
struct sockaddr_in serveraddr;
//使用IPV4
serveraddr.sin_family=AF_INET;
//我们需要绑定的IP地址，INADDR_ANY 就是0.0.0.0 ，就是所有网卡的所有IP段都可以连接到我们的创建的TCP服务器上。
serveraddr.sin_addr.s_addr=htonl(INADDR_ANY);
//我们需要绑定的端口，这里我们绑定的端口为9999
serveraddr.sin_port=htons(9999);
//第一个参数我们创建的套接字，第二个是我们填写的绑定信息，最后是我们的绑定信息结构体的大小。
if (-1==bind(listenfd,(const sockaddr*)&serveraddr,sizeof(serveraddr)))
{
return -2;
}
//监听我们创建的套接字，请求的队列数量，这里我们填写为10个
listen(listenfd,10);
//定义客户端的socket
;
while (1)
{
struct sockaddr_in client;
//客户端结构体的长度
socklen_t len=sizeof(client);
//等待接受连接
//第一个参数服务器的套接字，第二个接收到的客户端的socket，第三个函数就是结构体的长度
int clientfd=accept(listenfd,(struct sockaddr*)&client,&len);
if (clientfd<0)
{
close(listenfd);
return -3;
}
pid_t id=fork();
if (id<0)
{
perror("fork");
}else if (id==0)
{
close(listenfd);
pid_t idd= fork();
if (idd<0)
{
perror("second fork");
_exit(5);
}
else if (idd==0)
{
while (1)
{
//收函数
//第一个参数客户端的套接字，第二个参数，接受的缓冲区，第三个参数缓冲区的大小，第4个参数接收到的字节数
int ret = recv(clientfd,buffer,BUFFER_LENGTH,0);
if (ret<=0)
{
close(clientfd);
break;
}
printf("buffer: %s , ret : %d\n",buffer,ret);
//发函数
//第一个参数客户端的套接字，第二个参数，发送的缓冲区，第三个参数发送的字节数，第4个参数实际发送的字节数
ret = send(clientfd,buffer,ret,0);
}
}else{
_exit(6);
}
}
#if 0
//接受的缓冲区大小
unsigned char buffer[BUFFER_LENGTH]={0};
while (1)
{
//收函数
//第一个参数客户端的套接字，第二个参数，接受的缓冲区，第三个参数缓冲区的大小，第4个参数接收到的字节数
int ret = recv(clientfd,buffer,BUFFER_LENGTH,0);
if (ret<=0)
{
close(clientfd);
break;
}
printf("buffer: %s , ret : %d\n",buffer,ret);
//发函数
//第一个参数客户端的套接字，第二个参数，发送的缓冲区，第三个参数发送的字节数，第4个参数实际发送的字节数
ret = send(clientfd,buffer,ret,0);
}
#endif
}
return 0;
}
然后我们在看看通过第一种方式的多线程的方式来完成我们的TCP服务器
#include<stdio.h>
#include<sys/socket.h>
#include<sys/types.h>
#include<netinet/in.h>
#include<fcntl.h>
#include <unistd.h>
#include<thread>
#define BUFFER_LENGTH 128
void routine(void *arg) {
int clientfd = *(int *)arg;
while (1) {
unsigned char buffer[BUFFER_LENGTH] = {0};
int ret = recv(clientfd, buffer, BUFFER_LENGTH, 0);
if (ret == 0) {
close(clientfd);
break;
}
printf("buffer : %s, ret: %d\n", buffer, ret);
ret = send(clientfd, buffer, ret, 0); //
}
}
int main()
{
unsigned char buffer[BUFFER_LENGTH]={0};
//socket有两个参数，第一个参数指定我们要使用IPV4，还是IPV6，第二个参数表明我们要使用套接字类型，这里我们使用的是流格式的套接字，第三个参数就是我们需要使用传输协议
//这里使用0，表示让系统自动推导我们需要使用的传输协议。
int listenfd= socket(AF_INET,SOCK_STREAM,0);
//如果返回值为-1，说明我们创建SOCKET失败，直接返回。
if (listenfd==-1)
{
return -1;
}
//我们需要绑定的信息
struct sockaddr_in serveraddr;
//使用IPV4
serveraddr.sin_family=AF_INET;
//我们需要绑定的IP地址，INADDR_ANY 就是0.0.0.0 ，就是所有网卡的所有IP段都可以连接到我们的创建的TCP服务器上。
serveraddr.sin_addr.s_addr=htonl(INADDR_ANY);
//我们需要绑定的端口，这里我们绑定的端口为9999
serveraddr.sin_port=htons(9999);
//第一个参数我们创建的套接字，第二个是我们填写的绑定信息，最后是我们的绑定信息结构体的大小。
if (-1==bind(listenfd,(const sockaddr*)&serveraddr,sizeof(serveraddr)))
{
return -2;
}
//监听我们创建的套接字，请求的队列数量，这里我们填写为10个
listen(listenfd,10);
//定义客户端的socket
;
while (1)
{
struct sockaddr_in client;
//客户端结构体的长度
socklen_t len=sizeof(client);
//等待接受连接
//第一个参数服务器的套接字，第二个接收到的客户端的socket，第三个函数就是结构体的长度
int clientfd=accept(listenfd,(struct sockaddr*)&client,&len);
if (clientfd<0)
{
close(listenfd);
return -3;
}
std::thread t{&routine,&clientfd};
t.detach();
}
#if 0
//接受的缓冲区大小
unsigned char buffer[BUFFER_LENGTH]={0};
while (1)
{
//收函数
//第一个参数客户端的套接字，第二个参数，接受的缓冲区，第三个参数缓冲区的大小，第4个参数接收到的字节数
int ret = recv(clientfd,buffer,BUFFER_LENGTH,0);
if (ret<=0)
{
close(clientfd);
break;
}
printf("buffer: %s , ret : %d\n",buffer,ret);
//发函数
//第一个参数客户端的套接字，第二个参数，发送的缓冲区，第三个参数发送的字节数，第4个参数实际发送的字节数
ret = send(clientfd,buffer,ret,0);
}
#endif
return 0;
}
这样我们的就完成了我们TCP 单进程多线程服务器的创建，这里会有一个问题：如果我们就想要通过单线程完成我们的可以接受多个客户端的连接，我们应该怎么去实现那？
在这里，我大概讲一下我自己的理解，可能理解的不对，也是刚开始学，我是这样去理解，当我们使用单线程只能接受一个客户端的TCP服务器的时候，当我们连接第2个客户端的时候，ACCEPT是可以接收的，但是没有办法进行消息的收发，因此我们就有这样的一个思路去完成我们的需求，就是通过类似哈希表一样的结构，有一个新的连接连入我们的时候，我们就插入这个表，然后我们开始轮询遍历这个表中的连接，如果有读写的事件产生，我们就调用recv和send函数进行调用，完成我们的需求。
类似图片中的轮询，下面我们看一下使用select函数的代码是怎么样的。
#include<stdio.h>
#include<sys/socket.h>
#include<sys/types.h>
#include<netinet/in.h>
#include<fcntl.h>
#include <unistd.h>
#define BUFFER_LENGTH 128
int main()
{
unsigned char buffer[BUFFER_LENGTH]={0};
int ret=0;
//socket有两个参数，第一个参数指定我们要使用IPV4，还是IPV6，第二个参数表明我们要使用套接字类型，这里我们使用的是流格式的套接字，第三个参数就是我们需要使用传输协议
//这里使用0，表示让系统自动推导我们需要使用的传输协议。
int listenfd= socket(AF_INET,SOCK_STREAM,0);
//如果返回值为-1，说明我们创建SOCKET失败，直接返回。
if (listenfd==-1)
{
return -1;
}
//我们需要绑定的信息
struct sockaddr_in serveraddr;
//使用IPV4
serveraddr.sin_family=AF_INET;
//我们需要绑定的IP地址，INADDR_ANY 就是0.0.0.0 ，就是所有网卡的所有IP段都可以连接到我们的创建的TCP服务器上。
serveraddr.sin_addr.s_addr=htonl(INADDR_ANY);
//我们需要绑定的端口，这里我们绑定的端口为9999
serveraddr.sin_port=htons(9999);
//第一个参数我们创建的套接字，第二个是我们填写的绑定信息，最后是我们的绑定信息结构体的大小。
if (-1==bind(listenfd,(const sockaddr*)&serveraddr,sizeof(serveraddr)))
{
return -2;
}
//监听我们创建的套接字，请求的队列数量，这里我们填写为10个
listen(listenfd,10);
//定义客户端的socket
//定义可读序列和可写序列
fd_set rfds,wfds,rset,wset;
//清空序列
FD_ZERO(&rfds);
//设置读的序列
FD_SET(listenfd,&rfds);
//清空可写的序列
FD_ZERO(&wfds);
int maxfd=listenfd;
while (1)
{
//开始进行序列的赋值，
rset=rfds;
wset=wfds;
//select开始多路服用
//第一个参数是所有文件描述符的范围，第二个参数监控读的文件描述符的序列，第三个参数监控写的文件描述符的序列， 第4个参数监控异常的序列，第5个参数等待的时间，0是指无限等待
int nready=select(maxfd+1,&rset,&wset,NULL,NULL);
//判断listenfd服务器socket是否被设置，设置代表有效。
if (FD_ISSET(listenfd,&rset))
{
printf("listen --> \n");
struct sockaddr_in client;
socklen_t len = sizeof(client);
//开始接受客户端得连接
int clientfd = accept(listenfd, (struct sockaddr*)&client, &len);
//添加可读列表中
FD_SET(clientfd, &rfds);
//如果客户端的文件描述符的序号大于最大的文件描述符的编号
if (clientfd > maxfd) maxfd = clientfd;
}
int i = 0;
//开始轮询监听的已经连接的客户端的socket
for (i = listenfd+1; i <= maxfd;i ++) {
//如果有可读的事件
if (FD_ISSET(i, &rset)) { //
//开始接受信息
ret = recv(i, buffer, BUFFER_LENGTH, 0);
if (ret <= 0) {
close(i);
FD_CLR(i, &rfds);
} else if (ret > 0) {
//打印接受到信息
printf("buffer : %s, ret: %d\n", buffer, ret);
//设置可写的事件
FD_SET(i, &wfds);
}
//如果有可写的事件
} else if (FD_ISSET(i, &wset)) {
//开发发送消息
ret = send(i, buffer, ret, 0); //
//清空可写的事件
FD_CLR(i, &wfds);
//设置可读事件，因为并没有断开连接
FD_SET(i, &rfds);
}
}
}
return 0;
}
这样就完成了我们的select选择模型的代码。今天我们就介绍到这里。
推荐一个零声学院免费教程，个人觉得老师讲得不错，
分享给大家：[Linux，Nginx，ZeroMQ，MySQL，Redis，
fastdfs，MongoDB，ZK，流媒体，CDN，P2P，K8S，Docker，
TCP/IP，协程，DPDK等技术内容，点击立即学习:
服务器
音视频
dpdk
Linux内核
