linux 网络编程（3） --- 高并发服务器
高并发服务器
三种实现并发服务器
- 阻塞式
- 非阻塞忙轮询式
- 响应式 — 多路IO转接（能效最好）
多路IO转接
也叫做多任务IO服务器。该类服务器实现的主旨思想是，不再由应用程序自己监视客户端连接， 取而代之由内核代替程序监视文件
select函数
int select(int nfds, fd_set *restrict readfds, fd_set *restrict writefds, fd_set *restrict exceptfds, struct timeval *restrict timeout);
参数：
nfds：监听的所有文件描述符中，最大的文件描述符+1
readfds：读 文件描述符监听集合 传入，传出参数
writefds：写 文件描述符监听集合 传入，传出参数 通常写NULL
exceptfds：异常 文件描述符监听集合 传入，传出参数 通常写NULL
time：
>0: 设置监听超时时长
NULL： 阻塞监听
0： 非阻塞监听（需要轮询）
返回值：
>0: 所有监听集合中， 满足对应时间的总数
0： 没有满足监听条件的文件描述符
-1： 失败， 设置errno
对fd_set的一些操作函数
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); 清空一个文件描述符集合
使用select搭建高并发服务器
- 无需多线程和多进程即可实现多线程和多进程的效果（单线程/进程监听多个端口）
大体思路
lfd = socket(); 创建套接字
bind(); 绑定地址结构
listen(); 设置监听上限
fd_set rset, allset; 创建r监听集合和总集合
FD_ZERO(&allset); 将总集合清零
FD_SET(lfd, &allset); 将lfd添加至总集合
while (1) {
rset = allset 初始化读集合
ret = select(lfd + 1, &rset, NULL, NULL, NULL); 监听文件描述符集合对应事件
if (ret > 0) { 有监听的文件描述符满足对应事件
if (FD_ISSET(lfd, &rset)) { 当lfd在集合中时（说明有连接）
cfd = accept(); 建立连接，返回用于通信的文件描述符
FD_SET(cfd, &allset); 添加到监听通信描述符集合中
}
for (int i = ldf + 1; i <= 最大文件描述符; i ++) {
FD_ISSET(i, &rset) 有read,write事件
read()
{...}
write()
}
}
}
具体代码逻辑
#include "wrap.h"
#define server_port 443
int main()
{
int listenfd, connfd;
int n;
char buf[BUFSIZ];
struct sockaddr_in clit_addr, serv_addr;
socklen_t clit_addr_len;
listenfd = Socket(AF_INET, SOCK_STREAM, 0);
int opt = 1;
setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
bzero(&serv_addr, sizeof(serv_addr));
serv_addr.sin_port = htons(server_port);
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
Bind(listenfd, &serv_addr, sizeof(serv_addr));
Listen(listenfd, 128);
fd_set rset, allset; // 定义读集合
int ret , maxfd = listenfd; // 最大文件描述符
FD_ZERO(&allset); // 清空 监听集合
FD_SET(listenfd, &allset); // 将listenfd添加到监听集合中
while (1) {
rset = allset; // 备份
ret = select(maxfd + 1, &rset, NULL, NULL, NULL);
if (ret < 0) {
sys_err("select error");
}
if (FD_ISSET(listenfd, &rset)) { // listenfd满足监听的读事件
clit_addr_len = sizeof(clit_addr);
connfd = Accept(listenfd, &clit_addr, &clit_addr_len); // 不会阻塞
FD_SET(connfd, &allset); // 监听数据的读事件
if (maxfd < connfd) // 修改最大的fd
maxfd = connfd;
if (ret == 1) { // 说明select只返回一个，且是listenfd
continue;
}
}
for (int i = listenfd + 1; i <= maxfd; i++) { // 处理读事件的fd
if (FD_ISSET(i, &rset)) { // 找到满足的fd
n = read(i, buf, sizeof(buf));
if (n == 0) { // 若已经关闭连接了
close(i);
FD_CLR(i, &allset); // 移除监听集合
} else if (n == -1) {
sys_err("read error");
}
for (int j = 0; j < n; j++) {
buf[j] = toupper(buf[j]);
}
write(i, buf, n);
fprintf(stdout, "%s\n", buf);
}
}
}
close(listenfd);
return 0;
}
select优缺点
缺点：
- 监听上限受文件描述符的限制， 最大是1024个
- 检测满足条件的
fd， 自己添加业务逻辑来提高效率。提高了编码的难度。（注意：由于设计的问题，才导致了这个现象， 性能不低）
优点：
- 跨平台
poll函数
半成品， 可以不学
int poll(struct pollfd fds[], nfds_t nfds, int timeout);
参数：
fds：监听的文件描述符数组
nfds：监听数组的，实际有效的监听个数
timeout：超时时长（单位：毫秒）
-1： 阻塞等待
0： 立刻返回，不阻塞进程
>0： 等待指定的毫秒数，若当前系统事件精度不够，则向上取整
struct pollfd {
int fd; /* 文件描述符 */
short events; /* 监听的事件 */
POLLIN，POLLOUT，POLLERR，...
short revents; /* 传入时，给0值，如果满足对应的事件，则会返回非0 */
};
使用方法
struct pollfd pfds[1024];
pfds[0].fd = lfd;
pfds[0].events = POLLIN;
pfds[0].revents = 0;
pfds[0].fd = cfd1;
pfds[0].events = POLLIN;
pfds[0].revents = 0;
...
while(1) {
int ret = poll(pfds, 5, -1);
for(int i = 0; i < 5; i++) {
if (pfds[i].revents & POLLIN) {
Accept();
Read();
{ ... }
Write();
}
}
}
poll优缺点
优点：
- 自带数组结构，可将监听事件集合和返回事件集合分离
- 可以拓展监听上限，可超出1024限制
缺点：
- 不能跨平台
- 无法直接定位满足监听事件的文件描述符，编码难度较大。
epoll函数
epoll是linux下提供多路复用io借口select/poll的增强版，可以显著的提高程序在大量并发连接中只有少量活跃的情况下系统cpu的利用率。目前epoll是大规模并发网络程序中的热门首选模型。
查看一个进程可以打开的socket描述符的上限
cat /proc/sys/fs/file-max
epoll_create函数
作用：创建一个红黑二叉树
int epoll_create(int size)；
参数：
size： 创建的红黑数的监听节点数（仅供内核参考）
返回值：
成功：指向新创建的红黑树的根节点fd
失败：-1，设置errno
epoll_ctl函数
作用：设置监听红黑树
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
参数：
epfd：指向红黑树根节点的值
op：对该监听红黑树所作的操作
EPOLL_CTL_ADD：添加fd到监听红黑树中
EPOLL_CTL_MOD：修改fd在监听红黑树上的监听事件
EPOLL_CTL_DEL：将一个fd从监听红黑树摘下来（取消监听）
fd：待监听的fd
event：本质是一个struct epoll_event的 结构体 的地址
返回值：
成功：0
失败：-1,设置errno
struct epoll_event {
uint32_t events; /* Epoll events */
EPOLLIN，EPOLLOUT，EPOLLERR，...
epoll_data_t data; /* User data variable */
};
typedef union epoll_data {
void *ptr;
int fd; 对于监听事件的fd
uint32_t u32; 不用
uint64_t u64; 不用
} epoll_data_t;
epoll_wait函数
作用：监听事件
int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);
参数：
epfd: 红黑树的句柄
events：传出参数，数组，满足监听条件的fd结构体
maxevents:数组的元素的总个数（自己定义的数组events的长度）
timeout：超时时间
-1：阻塞
0：不阻塞
>0:超时事件，单位：毫秒
返回值：
>0 :满足监听的总个数（events中传出来的）。可以用作数组下标（循环的上限）
0：没有满足的监听的事件
-1：失败，设置errno
使用epoll实现多路IO的思路
lfs = socket(); // 监听连接事件
bind();
listen();
int epfd = epoll_create(); // epfd:监听红黑树的树根
struct epoll_event tep, ep[1024]; // tep 用来设置单个fd属性， ep是epol_wait传出的满足的监听事件的数组
tep.events = EPOLLIN; // 初始化lfd的监听属性
tep.data.fd = lfd;
epoll_ctl(epfd, EPOLL_CTL_ADD, lfd, &tep); // 将lfd添加到监听红黑树上
while (1) {
ret = pol_wait(wait, ep, 1024, -1); // 实施监听
check(ret); // 检查返回值
for (int i = 0; i < ret; i++) {
if (ep[i].data.fd == lfd) { // lfd满足读事件（有新的客户端发起连接请求）
cfd = accept();
tmp.events = EPOLLIN; // 初始化cfd的监听属性
tmp.data.fd = cfd;
epoll_ctl(epfd, EPOLL_CTL_ADD, cfd, &tep);
} else { // cfd满足读事件，有客户端写数据
n = read();
if (n == 0) { // 对端关闭
close(ep[i].data.fd); // 关闭socket
epoll_ctl(epfd, EPOLL_CTL_DEL, ep[i].data.fd, NULL); // 将关闭的fd,从监听树上摘下
} else if (n > 0) { // 读到了数据
{ ... } // 处理事件
write() // 回发数据
}
}
}
}
使用epoll搭建高并发服务器
#include 事件触发模型
有两种触发模型
ET边缘触发：有数据到来的时候才会触发，不管缓冲区中有没有数据
缓冲区剩余未读尽的数据不会导致epoll_wait触发，新的事件满足才会触发。
struct epoll_event event;
event.events = EPOLLIN | EPOLLE;
LT水平触发（默认）：只要有数据就会触发
缓冲区剩余未读尽的数据会导致epoll_wait触发
struct epoll_event event;
event.events = EPOLLIN;
比较：
- LT是缺省的工作方式， 并且同时支持
block的和no-block的两种socket.这样的模式编码出错概率会比较小， 同时select/poll都是这种模型的代表。当只需要用到一个文件的一部分的时候（例如读取一个文件的属性），就可以使用此模式。 - ET是高速工作模式（推荐使用这种），只支持
no-blocksocket，当文件描述符从未就绪变成就绪时，内核通过epoll告诉你。若没有io操作，使得文件变为未就绪态，内核则不会再次通知。通常与忙轮询相结合
fcntl实现文件的非阻塞（读数据的时候的非阻塞）
结论：
epoll的ET模式是高效模式，但是只支持非阻塞模式
设计思路：
flag = fcntl(cfd, F_GETFG); //设置非阻塞
flag |= O_NONBLOCK;
fcntl(cfd, F_SETFL, flag);
struct epoll_event event;
event.events = EPOLLIN | EPOLLET;
epoll.ctl(epfd, EPOLL_CTL_ADD, cfd, &event);
代码实现
#include epoll优缺点
优点：
- 高效
- 可以突破文件描述符的最大上限
缺点：
- 不能跨平台
epoll反应堆模型
epollET模式 + 非阻塞，轮询 +void *ptr
对比：
-
原来：
socket,bind,listen–epoll_create–epoll_ctl–epoll-wait– 对应监听fd有事件产生 – 返回监听满足数组 – 判断返回的元素 –lfd满足accept/cfd满足处理事物 –write -
反应堆：不但要监听
cfd的读事件，还要监听cfd的写事件socket,bind,listen–epoll_create–epoll_ctl–epoll-wait– 对应监听fd有事件产生 – 返回监听满足数组 – 判断返回的元素 –lfd满足accept/cfd满足处理事物 -> 将cfd从监听红黑树上摘下 ->EPOLLOUT-> 回调函数 ->epoll_ctl->EPOLL_CTL_ADD重新放回红黑树上，监听写事件 -> 等待epoll_wait返回（说明cfd可写） ->write写 ->cfd从监听树上摘下 ->EPOLLIN->epoll_wait->EPOLL_CTL_ADD重新放回红黑树上，监听写事件 ->epoll_wait
代码实现
/* epoll反应堆模型
*
*
*
*/
#include "wrap.h"
#include 线程池
与多路IO转接的区别：
- 多路IO转接处理的是客户端和服务器的连接和传输数据的问题
- 线程池处理的是服务器在拿到数据以后，处理数据的问题
线程池结构体
struct threadpool_t {
pthread_mutex_t lock; // 用于锁住本结构体
pthread_mutex_t thread_counter; // 记录忙状态线程个数的锁
pthread_cond_t queue_not_full; // 当任务队列满时， 添加人物的线程阻塞， 等待此条件变量
pthread_cond_t queue_not_empty; // 任务队列不为空时， 通知等待任务的线程
pthread_t *threads; // 存放线程池中每个线程的tid.数组
pthread_t adjust_tid; // 存任务管理线程tid
threadpool_task_t *task_queue; // 任务队列
int min_thr_num; // 线程池最小线程数
int max_thr_num; // 线程池最大线程数
int live_thr_num; // 当前存活线程个数
int busy_thr_num; // 忙状态线程个数
int wait_exit_thr_num; // 要销毁的线程个数
int queue_front; // task_queue队头下标
int queue_rear; // task_queue队尾下标
int queue_size; // task_queue中实际的任务数
int queue_max_size; // task_queue中可容纳的任务数的上限
int shutdown; // 标志位，线程池的状态， true或false
};
线程池main架构
1. main
创建线程池
向线程池中添加任务， 借助回调处理任务
销毁线程池
2. pthreadpool_create()
创建线程池结构体指针
初始化线程池结构体（N个成员变量）
创建N个任务
创建1个管理线程
失败时销毁开辟的空间
3. threadpool_thread()
进入子线程回调函数
接受参数 void*arg --> pool 结构体
加锁 --> 整个结构体的锁
判断条件变量 --> wait
4. adjust_thread()
循环10s一次
进入管理者线程
接受参数void *arg -->pool 结构体
加锁 --> lock --> 整个结构体锁
获取管理线程池要用到的变量 task_num live_num, busy_num
根据既定算法，使用上述3变量，判断是否应该创建，销毁，线程池中指定步长的线程
5. threadpool_add()
模拟产生任务
设置回调函数的处理， 处理任务。sleep（1）
内部实现：
加锁
初始化任务队列结构体成员（回调函数function, arg）
用环形队列机制，实现添加任务。借助队尾指针挪动 % 实现
唤醒阻塞在条件变量上的线程
解锁
6. 从3.中的wait之后继续执行，处理任务
加锁
获取任务的回调函数， 参数
用环形队列机制，实现处理任务。借助队头指针挪动 % 实现
唤醒阻塞在条件变量上的server
解锁
加锁
改忙线程数
解锁
执行处理任务的线程
加锁
7. 创建，销毁线程
管理线程根据task_num, live_num, busy_num
根据既定算法，使用上述3变量，判断是否应该创建，销毁，线程池中指定步长的线程
如果满足，创建条件：
pthread_create() 回调任务线程函数
如果满足，销毁条件
wait_exit_thr_num = 10;
signal给阻塞在条件变量山的线程发送假条件满足先好
从而使得wait的线程会被唤醒，然后pthread_exit()
代码实现
#include UDP服务器
TCP通信和UDP通信的优缺点：
**TCP：**面向连接的，可靠数据包传输
- 对于不稳定的网络层，采用完全弥补的通信方式 —> 丢包重传
优点：
- 稳定
- 数据的流量，速度，顺序稳定
缺点：
- 传输速度慢，效率相对较低，系统资源开销大。
**使用场景：**数据的完整性要求较高， 不追求效率。（大数据，文件的传输）
**UDP：**无连接的，不可靠的数据包传递
- 对于不稳定的网络层，采取完全不弥补的通信方式 —> 默认还原网络状况
优点：
- 传输速度快，效率相对较高， 系统资源开销小。
缺点：
- 不稳定
- 数据的流量，速度，顺序不稳定
使用场景：时效性要求较高，稳定性其次。（游戏，视频会议，视频电话）
可以在应用层进行数据校验，从而来弥补udp的不足
UDP实现的C/S模型
-
accept()和connect()被舍弃 -
recv()/ send()只能用于TCP通信。用来代替read()/write()
server:
lfd = socket(AF_INET, SOCK_DGRAM, 0);
bind();
listen(); ---可有可无
while(1) {
recvfrom(cfd, buf, ) --- 被替换为recvfrom()
{ ... }
write(); --- 被替换为sendto()
}
close();
client:
connfd = socket(AF_INET, SOCK_DGRAM, 0);
sendto(connfd, "服务器的地址结构"， 地址结构的大小);
recvfrom();
close();
recvfrom函数
作用：连接并从一个地方读取数据
ssize_t recvfrom(int socket, void *restrict buffer, size_t length, int flags, struct sockaddr *restrict address, socklen_t *restrict address_len);
参数：
socket：套接字
buffer：读取的数据存放的缓冲区
length：缓冲区的大小
flags：默认传0
address：传出参数，对端的地址结构
address_len：传入传出参数，对端的地址结构的大小
返回值：
成功：接收数据字节数
失败：-1, 设置errno
0：对端关闭
sendto函数
作用：向指定的地方发送数据
ssize_t sendto(int socket, const void *message, size_t length, int flags, const struct sockaddr *dest_addr, socklen_t dest_len);
参数：
socket: 套接字
message: 存储数据的缓冲区
length: 数据长度
flags: 默认为0
dest_addr: 目标的地址结构(不可以省略)
dest_len: 目标地址结构的长度
返回值：
成功：成功写出的数据字节数
失败：-1,设置errno
代码实现
server.cpp
#include client.cpp
#include 本地套接字
**IPC（进程间通信）：**pipe, fifo, mmap, 信号， 本地套接字（domain）
对比网络编程TCP C/S模型：
- socket函数的参数domain：应取
AT_UNIX, type:无限制， protocal：无限制 - bind函数的地址结构：取
sockaddr_un类型 - 初始化
struct sockaddr_un {
sa_family_t sun_family; /* 地址结构类型 */
char sun_path[108]; /* socket文件名（路径） 路径的长度最大为108*/
};
初始化示例：
srv_addr.sun_family = AF_UNIX;
strcpy(srv.addr.sum_path, "srv.socket");
- 获取地址类型的大小需要用
offsetof()函数
作用：获取成员的偏移量
size_t offsetof(type, member);
参数：
type：类型
member：成员
返回值：
偏移量
len = offsetof(struct sockaddr_un, sun_path) + strlen("srv.socket");
bind(fd, (struct sockaddr*)&srv_addr, len);
-
bind函数创建成功，会创建一个socket。因此，为了保证bind成功，通常会在bind前，unlink() -
客户端不能依赖隐式绑定。并且在通信建立的过程中，创建且初始化2个地址结构：
- client_addr -> bind
- server_addr -> connect
注意点：
server和client的socket文件都是伪文件，即不占用磁盘的空间（通过bind函数创建出来的）
代码实现
注意：在本代码中，server和client要在同一个目录下
server
#include "wrap.h"
#include client
#include