Linux简单高并发模型——Epoll + 线程池

版权声明：本文为博主原创文章，遵循 CC 4.0 by-sa 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_25425023/article/details/70199133
首先是一个locker.h的文件，封装了信号量、互斥量、条件变量。

在线程池中的任务队列需要互斥量的保护，当任务队列中有任务到达时，需要唤醒一个等待pthread_cond_wait()的线程，线程池停止时，需要唤醒所以的线程，调用的是pthread_cond_broadcast()。

locker.h文件：

#ifndef _LOCKER_H_
#define _LOCKER_H_
 
#include <pthread.h>
#include <stdio.h>
#include <semaphore.h>
 
/*信号量的类*/
class sem_locker
{
private:
    sem_t m_sem;
 
public:
    //初始化信号量
    sem_locker()
    {
    if(sem_init(&m_sem, 0, 0) != 0)
        printf("sem init error\n");
    }
    //销毁信号量
    ~sem_locker()
    {
    sem_destroy(&m_sem);
    }
 
    //等待信号量
    bool wait()
    {
    return sem_wait(&m_sem) == 0;
    }
    //添加信号量
    bool add()
    {
    return sem_post(&m_sem) == 0;
    }
};
 
 
/*互斥 locker*/
class mutex_locker
{
private:
    pthread_mutex_t m_mutex;
 
public:
    mutex_locker()
    {
        if(pthread_mutex_init(&m_mutex, NULL) != 0)
        printf("mutex init error!");
    }
    ~mutex_locker()
    {
    pthread_mutex_destroy(&m_mutex);
    }
 
    bool mutex_lock()  //lock mutex
    {
    return pthread_mutex_lock(&m_mutex) == 0;
    }
    bool mutex_unlock()   //unlock
    {
    return pthread_mutex_unlock(&m_mutex) == 0;
    }
};
 
/*条件变量 locker*/
class cond_locker
{
private:
    pthread_mutex_t m_mutex;
    pthread_cond_t m_cond;
 
public:
    // 初始化 m_mutex and m_cond
    cond_locker()
    {
    if(pthread_mutex_init(&m_mutex, NULL) != 0)
        printf("mutex init error");
    if(pthread_cond_init(&m_cond, NULL) != 0)
    {   //条件变量初始化是被，释放初始化成功的mutex
        pthread_mutex_destroy(&m_mutex);
        printf("cond init error");
    }
    }
    // destroy mutex and cond
    ~cond_locker()
    {
    pthread_mutex_destroy(&m_mutex);
    pthread_cond_destroy(&m_cond);
    }
    //等待条件变量
    bool wait()
    {
    int ans = 0;
    pthread_mutex_lock(&m_mutex);
    ans = pthread_cond_wait(&m_cond, &m_mutex);
    pthread_mutex_unlock(&m_mutex);
    return ans == 0;
    }
    //唤醒等待条件变量的线程
    bool signal()
    {
    return pthread_cond_signal(&m_cond) == 0;
    }
 
    //唤醒all等待条件变量的线程
    bool broadcast()
    {
            return pthread_cond_broadcast(&m_cond) == 0;
    }
};
 
#endif

thread_pool.h文件。

创建threadnum个线程，并调用pthread_detach()分离线程，线程结束，自动回收资源。（前面的一篇博客的线程池有bug，不完整，线程池退出时，不能让所有的线程正常退出）

#ifndef _PTHREAD_POOL_
#define _PTHREAD_POOL_
 
#include "locker.h"
#include <queue>
#include <stdio.h>
#include <exception>
#include <errno.h>
#include <pthread.h>
#include <iostream>
 
template<class T>
class threadpool
{
private:
    int thread_number;  //线程池的线程数
    //int max_task_number;  //任务队列中的最大任务数
    pthread_t *all_threads;   //线程数组
    std::queue<T *> task_queue; //任务队列
    mutex_locker queue_mutex_locker;  //互斥锁
    //sem_locker queue_sem_locker;   //信号量
    cond_locker queue_cond_locker; //cond
    bool is_stop; //是否结束线程
public:
    threadpool(int thread_num = 20);
    ~threadpool();
    bool append_task(T *task);  //添加任务
    void start();              //线程池开启
    void stop();               //线程池关闭
private:
    //线程运行的函数。执行run()函数
    static void *worker(void *arg);
    void run();
    T *getTask();   //获取任务
};
 
template <class T>
threadpool<T>::threadpool(int thread_num):
    thread_number(thread_num),is_stop(false), all_threads(NULL)
{       //构造函数
    if(thread_num <= 0)
    printf("threadpool can't init because thread_number = 0");
 
    all_threads = new pthread_t[thread_number];
    if(all_threads == NULL)
        printf("can't init threadpool because thread array can't new");
}
 
template <class T>
threadpool<T>::~threadpool()
{
    delete []all_threads;
    stop();
}
 
template <class T>
void threadpool<T>::stop() //线程池停止
{
        is_stop = true;
        //queue_sem_locker.add();
        queue_cond_locker.broadcast();
}
 
template <class T>
void threadpool<T>::start()  //线程池启动
{
    for(int i = 0; i < thread_number; ++i)
    {
    //printf("create the %dth pthread\n", i);
    if(pthread_create(all_threads + i, NULL, worker, this) != 0)
    {//创建线程失败，清除成功申请的资源并抛出异常
        delete []all_threads;
        throw std::exception();
    }
    if(pthread_detach(all_threads[i]))
    {//将线程设置为脱离线程，失败则清除成功申请的资源并抛出异常
        delete []all_threads;
        throw std::exception();
    }
    }
}
//添加任务进入任务队列
template <class T>
bool threadpool<T>::append_task(T *task)   //添加任务
{   //获取互斥锁
    queue_mutex_locker.mutex_lock();
    
    bool is_signal = task_queue.empty();
    //添加进入队列
    task_queue.push(task);
    queue_mutex_locker.mutex_unlock();
    //唤醒等待任务的线程
    if(is_signal)
    {
            queue_cond_locker.signal();
    }
    return true;
}
 
template <class T>
void *threadpool<T>::worker(void *arg)  //线程工作函数
{
    threadpool *pool = (threadpool *)arg;
    pool->run();
    return pool;
}
 
template <class T>
T* threadpool<T>::getTask()   //从任务队列中获取任务
{
    T *task = NULL;
    queue_mutex_locker.mutex_lock();
    if(!task_queue.empty())
    {
        task = task_queue.front();
        task_queue.pop();
    }
    queue_mutex_locker.mutex_unlock();
    return task;
}
 
template <class T>
void threadpool<T>::run()
{
    while(!is_stop){
        T *task = getTask();
        if(task == NULL)  //队列为空，等待
                queue_cond_locker.wait();
        else              //执行任务
                task->doit();
    }
    //for test
    //printf("exit%d\n", (unsigned long)pthread_self());
}
 
#endif
 
 

封装了epoll。
EpollServer.h中的BaseTask.h和Task.h应该放在另外一个文件中的。这里图个方便，哈哈。

#ifndef _EPOLL_SERVER_H_
#define _EPOLL_SERVER_H_
 
#include <sys/socket.h>
#include <sys/types.h>
#include <stdio.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/wait.h>
#include <sys/epoll.h>
//#include <pthread.h>
 
#include "thread_pool.h"
 
#define MAX_EVENT 1024   //epoll_events的最大个数
#define MAX_BUFFER 2048  //Buffer的最大字节
 
class BaseTask
{
public:
    virtual void doit() = 0;
};
 
class Task : public BaseTask
{
private:
    int sockfd;
    char order[MAX_BUFFER];
public:
    Task(char *str, int fd) : sockfd(fd)
    {
        memset(order, '\0', MAX_BUFFER);
        strcpy(order, str);
    }
    void doit()  //任务的执行函数
    {
        //do something of the order
        //printf("%s\n", order);
        snprintf(order, MAX_BUFFER - 1, "somedata\n");
        write(sockfd, order, strlen(order));
    }
};
 
class EpollServer
{
private:
    bool is_stop;   //是否停止epoll_wait的标志
    int threadnum;   //线程数目
    int sockfd;     //监听的fd
    int port;      //端口
    int epollfd;    //Epoll的fd
    threadpool<BaseTask> *pool;   //线程池的指针
    //char address[20];
    epoll_event events[MAX_EVENT];  //epoll的events数组
    struct sockaddr_in bindAddr;   //绑定的sockaddr
 
public://构造函数
    EpollServer()
    {}
    EpollServer(int ports, int thread) : is_stop(false) , threadnum(thread) ,
        port(ports), pool(NULL)
    {
    }
    ~EpollServer()  //析构
    {
        delete pool;
    }
 
    void init();
 
    void epoll();
 
    static int setnonblocking(int fd)  //将fd设置称非阻塞
    {
        int old_option = fcntl(fd, F_GETFL);
        int new_option = old_option | O_NONBLOCK;
        fcntl(fd, F_SETFL, new_option);
        return old_option;
    }
 
    static void addfd(int epollfd, int sockfd, bool oneshot)  //向Epoll中添加fd
    {//oneshot表示是否设置称同一时刻，只能有一个线程访问fd，数据的读取都在主线程中，所以调用都设置成false
        epoll_event event;
        event.data.fd = sockfd;
        event.events = EPOLLIN | EPOLLET;
        if(oneshot)
        {
            event.events |= EPOLLONESHOT;
        }
        epoll_ctl(epollfd, EPOLL_CTL_ADD, sockfd, &event); //添加fd
        EpollServer::setnonblocking(sockfd);
    }
 
};
 
void EpollServer::init()   //EpollServer的初始化
{
    bzero(&bindAddr, sizeof(bindAddr));
    bindAddr.sin_family = AF_INET;
    bindAddr.sin_port = htons(port);
    bindAddr.sin_addr.s_addr = htonl(INADDR_ANY);
        //创建Socket
    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if(sockfd < 0)
    {
        printf("EpollServer socket init error\n");
        return;
    }
    int ret = bind(sockfd, (struct sockaddr *)&bindAddr, sizeof(bindAddr));
    if(ret < 0)
    {
        printf("EpollServer bind init error\n");
        return;
    }
    ret = listen(sockfd, 10);
    if(ret < 0)
    {
        printf("EpollServer listen init error\n");
        return;
    }
        //create Epoll
    epollfd = epoll_create(1024);
    if(epollfd < 0)
    {
        printf("EpollServer epoll_create init error\n");
        return;
    }
    pool = new threadpool<BaseTask>(threadnum);  //创建线程池
}
 
void EpollServer::epoll()
{
    pool->start();   //线程池启动
    //
    addfd(epollfd, sockfd, false);
    while(!is_stop)
    {//调用epoll_wait
        int ret = epoll_wait(epollfd, events, MAX_EVENT, -1);
        if(ret < 0)  //出错处理
        {
            printf("epoll_wait error\n");
            break;
        }
        for(int i = 0; i < ret; ++i)
        {
            int fd = events[i].data.fd;
            if(fd == sockfd)  //新的连接到来
            {
                struct sockaddr_in clientAddr;
                socklen_t len = sizeof(clientAddr);
                int confd = accept(sockfd, (struct sockaddr *)
                    &clientAddr, &len);
 
                EpollServer::addfd(epollfd, confd, false);
            }
            else if(events[i].events & EPOLLIN)  //某个fd上有数据可读
            {
                char buffer[MAX_BUFFER];
        readagain:    memset(buffer, 0, sizeof(buffer));
                int ret = read(fd, buffer, MAX_BUFFER - 1);
                if(ret == 0)  //某个fd关闭了连接，从Epoll中删除并关闭fd
                {
                    struct epoll_event ev;
                    ev.events = EPOLLIN;
                    ev.data.fd = fd;
                    epoll_ctl(epollfd, EPOLL_CTL_DEL, fd, &ev);
                    shutdown(fd, SHUT_RDWR);
                    printf("%d logout\n", fd);
                    continue;
                }
                else if(ret < 0)//读取出错，尝试再次读取
                {
                    if(errno == EAGAIN)    
                    {
                        printf("read error! read again\n");
                        goto readagain;
                            break;
                    }
                }
                else//成功读取，向线程池中添加任务
                {
                    BaseTask *task = new Task(buffer, fd);
                    pool->append_task(task);
                }
            }
            else
            {
                printf("something else had happened\n");
            }
        }
    }
    close(sockfd);//结束。
 
    pool->stop();
}
 
#endif

接下来是简单的Demo的测试。

#include "EpollServer.h"
 
int main(int argc, char const *argv[])
{
    if(argc != 3)
    {
        printf("usage %s port threadnum\n", argv[0]);
        return -1;
    }
    int port = atoi(argv[1]);
    if(port == 0)
    {
        printf("port must be Integer\n");
        return -1;
    }
    int threadnum = atoi(argv[2]);
    if(port == 0)
    {
        printf("threadnum must be Integer\n");
        return -1;
    }
    EpollServer *epoll = new EpollServer(port, threadnum);
 
    epoll->init();
 
    epoll->epoll();
    return 0;
}

代码在Ubuntu中编译通过。下次再来更新能够支持并发量的多少。

-------------------------------------------------------------------------------------------------

 ———————————————— 
版权声明：本文为CSDN博主「XD灬」的原创文章，遵循CC 4.0 by-sa版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_25425023/article/details/70199133

转载于:https://my.oschina.net/u/4000302/blog/3098482