epoll加线程池

#include<unistd.h>
#include <cstdio>
#include<sys/socket.h>
#include<sys/epoll.h>
#include<arpa/inet.h>
#include<netinet/in.h>
#include<fcntl.h>
#include<pthread.h>
#include<stdlib.h>
#include<memory.h>
#include<iostream>


using namespace std;

int epfd;
pthread_mutex_t mutex_epoll=PTHREAD_MUTEX_INITIALIZER;

//队列不带头节点，队列尾插头出
#define que_push_item(que,item) do{                      \
    if(que==nullptr){                                   \
        que=item;                                       \
        que->prev=nullptr;                              \
        que->next=nullptr;                              \
    }else{                                              \
        while(que->next!=nullptr){                      \
            que = que->next;                            \
        }                                               \
        que->next=item;                                 \
        item->next = nullptr;                           \
        item->prev = que;                               \
        while(que->prev !=nullptr){                     \
            que = que->prev;                            \
        }                                               \
    }                                                   \
}while(0)


#define que_pop(que) do{                                        \
    if (que == nullptr) {                                       \
        break;                                                  \
    }                                                           \
    else if (que->next == nullptr) {                            \
        que = nullptr;                                          \
    }                                                           \
    else {                                                      \
        que = que->next;                                        \
        que->prev = nullptr;                                    \
    }                                                           \
}while(0)

void* worktodo(void*);
typedef struct Worker_t {
   
   //工作线程，创建之后就执行等待任务到来的函数
    pthread_t tid;
    void* (*work)(void* arg);
    void* arg;
    //int len;指针所指向arg的内存大小

    struct Worker_t *prev;//用于组成队列便于manager管理
    struct Worker_t* next;
    Worker_t() {
   
   
        tid = 0;
        work = worktodo;
        arg = nullptr;
        prev = nullptr;
        next = nullptr;
        //len = 0;
    }

}worker_t;



typedef struct Task_t {
   
   //任务，包括任务数据和拿到数据的之后需要执行的函数
    void* (*task)(void* arg);//任务函数
    void* arg;//拿到的任务数据

    struct Task_t *prev;//用于组成任务队列，便于manager管理
    struct Task_t *next;
    Task_t() {
   
   
        task = nullptr;
        arg = nullptr;
        prev = nullptr;
        next = nullptr;
    }
}task_t;



typedef struct Manager_t {
   
   //一个线程池只需要一个管理者所以不需要组成队列
    void* (*manager)(void* arg);//管理者函数
    void* arg;//manager参数
    pthread_t tid;

    Manager_t() {
   
   
        manager = nullptr;
        arg = nullptr;
    }
}manager_t;



typedef struct PthreadPool_t {
   
   
    worker_t* workers;//工作线程队列
    task_t* tasks;//任务队列
    manager_t manager;//管理者

    int min_worker;//最小工作者线程数
    int max_worker;//最大工作者线程数

    int busy_worker;//正在执行任务的工作线程数，便于管理者动态根据目前的繁忙程度动态调整线程数
    int now_worker;//现有工作线程数

    pthread_mutex_t mutex;//用于对线程池的互斥修改
    pthread_cond_t cond_task_arrive;//条件变量，用于等待任务队列不为空的条件而唤醒线程
    pthread_cond_t cond_change_worker;//条件变量，当线程数应该调整时，唤醒管理者进行对应调整

    int kill;//当线程控线太多时，需要杀死的线程数

    PthreadPool_t() {
   
   
        workers = nullptr;
        tasks = nullptr;
        
        min_worker = 0;
        max_worker = 0;

        busy_worker = 0;
        now_worker = 0;

        mutex = PTHREAD_MUTEX_INITIALIZER;
        cond_change_worker = PTHREAD_COND_INITIALIZER;
        cond_task_arrive = PTHREAD_COND_INITIALIZER;

        kill = 0;
    }


}pthreadpool_t;


worker_t *find(worker_t* que,p