linux多线程或多进程epoll处理accept惊问题
什么是惊
简单说，惊是因为多进程（多线程）在同时阻塞等待同⼀个事件的时候（休眠状态），当时间发⽣时，就会唤醒所有等待的（休眠的）进程（线程）。但是事件只能被⼀个进程或线程处理，⽽其他进程（线程）获取失败，只能重新进⼊休眠状态，这种现象和性能浪费就叫做惊。
产⽣惊的条件
1. 多个进程或者多个线程
2. 同时等待处理⼀个事件
具体场景复现
测试环境 :
1. debian11
2. 内核5.10.0-8
3. 编译器 clang11
多线程和多进程在惊问题上差不多，为了少些⼀点，下⽂中没有特殊说明，多线程 也包含了多进程
在linux中，使⽤C/C++ 编写 tcp server时，会依次调⽤ socket() bind() listen() accept() 这⼏个函数，这⼏个函数会打开socket，绑定ip和端⼝，开始监听端⼝，accept函数会阻塞当前进程，等待客户端连接。
如果在单线程中，只有⼀个accept函数在等待客户端连接，当客户端来连接的时候，只会有⼀个accept函数来处理，所以也不会存在惊问题了。
在多线模型中，多个线程分别accept同⼀个socket，当有客户端连接时，内核会通知所有的线程来处理这个请求，但是呢，请求只能被⼀个线程处理，其他的线程的不到这个事件，只能⽩⽩被唤醒。
这是最简单的⼀种惊，这种情况在linux2.6以后就不会产⽣了。因为在Linux 2.6 版本之后，通过引⼊⼀个标记位
WQ_FLAG_EXCLUSIVE，解决掉了 Accept 惊效应。我原本还想在centos3.9（内核版本是2.5）中去复现这种情况，但是折腾了好久，也没能在centos上编译也运⾏C++程序，遂放弃。 不废话了，上代码，测试第⼀种情况
#include <netinet/in.h>
#include <iostream>
#include <sys/epoll.h>
#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
#define WORKER_THREAD 4
//创建socket，并返回fd
int createSocket() {
int fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (fd < 0) {
std::cout << "create socket error" << std::endl;
return 0;
}
sockaddr_in sockAddr{};
sockAddr.sin_port = htons(PORT);
sockAddr.sin_family = AF_INET;
sockAddr.sin_addr.s_addr = htons(INADDR_ANY);
if (bind(fd, (sockaddr *) &sockAddr, sizeof(sockAddr)) < 0) {
std::cout << "bind socket error, port:" << PORT << std::endl;
return 0;
return 0;
}
if (listen(fd, 100) < 0) {
std::cout << "listen port error" << std::endl;
return 0;
}
return fd;
}
void Worker1(int socketFd, int k) {
std::cout << " Worker" << k << " run " << std::endl;
while (true) {
int tfd = 0;
sockaddr_in cli_addr{};
socklen_t length = sizeof(cli_addr);
std::cout << "worker" << k << " in " << std::endl;
tfd = accept(socketFd, (sockaddr *) &cli_addr, &length);
if (tfd <= 0) {
std::cout << "accept error" << std::endl;
return;
} else {
std::cout << "worker" << k << " accept " << std::endl;
}
}
}
int main() {
std::mutex mutex;
std::unique_lock<std::mutex> lck(mutex);
std::condition_variable cv;
int fd = createSocket();
//第⼀种，多个线程不使⽤多路复⽤,accept同⼀个socket
for (int i = 0; i < WORKER_THREAD; ++i) {
std::thread th(&Worker1, fd, i + 1);
th.detach();
一个线程可以包含多个进程}
cv.wait(lck);
return 0;
}
这代码可以⽤C写，但是习惯⽤C++了，就⽤C++写吧。代码也⽐较简单，createSocket()创建了⼀个socket，然后4个线程分别去accept这个socket。 下⾯是运⾏结果：
可以看到，4个线程都在运⾏，并且accept，但是当连接来的时候，只有个线程能得到事件。
既然linux内核已经帮我们处理了惊，那我们还考虑这些⼲啥，直接⽤不就完了。
但是，我们在写代码的时候⼀般不会直接阻塞accept的，都是使⽤多路复⽤来帮我们处理连接阻塞的是多路复⽤函数。⽬前综合性能⽐较好的IO多路复⽤是epoll。当在多线程中使⽤epoll时，惊问题就会出现了。 先代码和结果，然后再解释
#include <netinet/in.h>
#include <iostream>
#include <sys/epoll.h>
#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
#define WORKER_THREAD 4
//创建socket，并返回fd
int createSocket() {
int fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (fd < 0) {
std::cout << "create socket error" << std::endl;
return 0;
}
sockaddr_in sockAddr{};
sockAddr.sin_port = htons(PORT);
sockAddr.sin_family = AF_INET;
sockAddr.sin_addr.s_addr = htons(INADDR_ANY);
if (bind(fd, (sockaddr *) &sockAddr, sizeof(sockAddr)) < 0) {
std::cout << "bind socket error, port:" << PORT << std::endl;
return 0;
}
if (listen(fd, 100) < 0) {
std::cout << "listen port error" << std::endl;
return 0;
}
return fd;
}
void Worker2(int socketFd, int k) {
std::cout << " Worker" << k << " run " << std::endl;
int eFd = epoll_create(1);
if (eFd < 0) {
std::cout << "create epoll fail";
return;
}
epoll_event epev_{};
epev_.events = EPOLLIN;
epev_.data.fd = socketFd;
epoll_ctl(eFd, EPOLL_CTL_ADD, socketFd, &epev_);
epoll_event events[EVENT_NUM];
while (true) {
int eNum = epoll_wait(eFd, events, EVENT_NUM, -1);
if (eNum == -1) {
std::cout << "epoll error";
return;
}
//⼀定要加上这句，防⽌事件被瞬间处理，导致看不到结果
std::this_thread::sleep_for((std::chrono::seconds (1)));
std::cout << "worker" << k << " in " << std::endl;
for (int i = 0; i < eNum; ++i) {
if (events[i].data.fd == socketFd) {
int tfd = 0;
sockaddr_in cli_addr{};
socklen_t length = sizeof(cli_addr);
socklen_t length = sizeof(cli_addr);
tfd = accept(socketFd, (sockaddr *) &cli_addr, &length);
if (tfd <= 0) {
std::cout << "accept error" << std::endl;
} else {
std::cout << "worker" << k << " accept " << std::endl;
}
} else {
/
/处理正常的socket读写事件，这⾥可以忽略，不是这次关注的点
}
}
}
}
int main() {
std::mutex mutex;
std::unique_lock<std::mutex> lck(mutex);
std::condition_variable cv;
int fd = createSocket();
//第⼆种，多个线程使⽤epoll多路复⽤,accept同⼀个socket
for (int i = 0; i < WORKER_THREAD; ++i) {
std::thread th(&Worker2, fd, i + 1);
th.detach();
}
}
结果
这⾥可以看到，当有客户端来连接的时候，4个线程都被唤醒了，但是只有workr2 线程成功获取了事件，其余的3个线程都⽩⽩唤醒浪费了性能
情景下的惊问题，第⼆种情景下的惊问题为啥就不处理了呢？
相关视频推荐
后台开发第400讲|6种epoll的做法，从redis，memcached到nginx的⽹络模型实现|1. epoll的封装模式 2. reactor的作⽤与原
需要C/C++ Linux服务器架构师学习资料加获取（资料包括C/C++，Linux，golang技
术，Nginx，ZeroMQ，MySQL，Redis，fastdfs，MongoDB，ZK，流媒体，CDN，P2P，K8S，Docker，TCP/IP，协
程，DPDK，ffmpeg等），免费分享
我的猜想不⼀定正确，如果有错误，请指出：
accept 只能是被⼀个进程调⽤成功（连接事件只会处理⼀次嘛），所以内核就直接处理了（⼀个accept只会唤醒⼀个进程）。但epoll 不⼀样，epoll中管理了很多连接，不⽌socket这⼀个，除了可能后续被 accept 调⽤外，还有可能是其他⽹络 IO 事件的，⽽其他 IO 事件是否只能由⼀个进程处理，是不⼀定的，这是⼀个由⽤户决定的事情，例如可能⼀个⽂件会由多个进程来读写。所以，对epoll 默认对于多进程监听同⼀⽂件不会设置互斥，所以就导致了epoll惊问题。
在linux4.5内核之后给epoll添加了⼀个 EPOLLEXCLUSIVE的标志位，如果设置了这个标志位，那epoll将进程挂到等待队列时将会设置⼀下互斥标志位，这时实现跟内核原⽣accept⼀样的特性，只会唤醒队列中的⼀个进程。
修改⼀下worker2函数:
版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。
发表评论