c++ 线程池模板

最新推荐文章于 2024-02-22 09:51:45 发布
原创 最新推荐文章于 2024-02-22 09:51:45 发布 · 268 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++ #服务器 

#ifndef PROCESSPOOL_H
#define PROCESSPOOL_H

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <assert.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <fcntl.h>
#include <stdlib.h>
#include <sys/epoll.h>
#include <signal.h>
#include <sys/wait.h>
#include <sys/stat.h>

class process
{
public:
    process() : m_pid(-1) {}

public:
    pid_t m_pid;
    int m_pipefd[2]; // 父进程和子进程通信用管道
};

template <typename T> // 模板参数是处理逻辑任务的类
class processpool
{
private:
    // 定义为私有，只能通过create静态函数来创建processpool实例
    processpool(int listenfd, int process_number = 8);

public:
    // 单例模式，是程序正确处理信号的必要条件
    static processpool<T> *create(int listenfd, int process_number = 8)
    {
        if (!m_instance)
        {
            m_instance = new processpool<T>(listenfd, process_number);
        }
        return m_instance;
    }
    ~processpool()
    {
        delete[] m_sub_process;
    }
    void run();

private:
    void setup_sig_pipe();
    void run_parent();
    void run_child();

private:
    static const int MAX_PROCESS_NUMBER = 16; // 最大子进程数量
    static const int USER_PER_PROCESS = 65536; // 每个子进程处理最大客户数量
    static const int MAX_EVENT_NUMBER = 10000; // epoll最多能处理的事件数
    int m_process_number; // 进程总数
    int m_idx; // 子进程在池中序号
    int m_epollfd; // 每个进程有个epoll内核事件表
    int m_listenfd; // 监听socket
    int m_stop; // 子进程通过m_stop判断是否停止运行
    process *m_sub_process; // 保存所有子进程描述信息
    static processpool<T> *m_instance; // 进程池静态实例
};
template <typename T>
processpool<T> *processpool<T>::m_instance = NULL;

static int sig_pipefd[2]; // 信号管道 统一事件源

static int setnonblocking(int 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 fd)
{
    epoll_event event;
    event.data.fd = fd;
    event.events = EPOLLIN | EPOLLET;
    epoll_ctl(epollfd, EPOLL_CTL_ADD, fd, &event);
    setnonblocking(fd);
}

static void removefd(int epollfd, int fd) // 从epollfd表示的内核事件表中删除fd的 所有事件
{
    epoll_ctl(epollfd, EPOLL_CTL_DEL, fd, 0);
    close(fd);
}

static void sig_handler(int sig)
{
    int save_errno = errno;
    int msg = sig;
    send(sig_pipefd[1], (char *)&msg, 1, 0);
    errno = save_errno;
}

static void addsig(int sig, void(handler)(int), bool restart = true)
{
    struct sigaction sa;
    memset(&sa, '\0', sizeof(sa));
    sa.sa_handler = handler;
    if (restart)
    {
        sa.sa_flags |= SA_RESTART;
    }
    sigfillset(&sa.sa_mask);
    assert(sigaction(sig, &sa, NULL) != -1);
}

template <typename T>
processpool<T>::processpool(int listenfd, int process_number) // 进程池构造函数，参数listenfd是监听的socket，必须在创建进程池之前被创建
    : m_listenfd(listenfd), m_process_number(process_number), m_idx(-1), m_stop(false)
{
    assert((process_number > 0) && (process_number <= MAX_PROCESS_NUMBER));

    m_sub_process = new process[process_number];
    assert(m_sub_process);

    for (int i = 0; i < process_number; ++i)
    {
        int ret = socketpair(PF_UNIX, SOCK_STREAM, 0, m_sub_process[i].m_pipefd);
        assert(ret == 0);

        m_sub_process[i].m_pid = fork();
        assert(m_sub_process[i].m_pid >= 0);
        if (m_sub_process[i].m_pid > 0) // 父进程
        {
            close(m_sub_process[i].m_pipefd[1]); // 只向子进程写
            continue;
        }
        else // 子进程
        {
            close(m_sub_process[i].m_pipefd[0]); // 只从父进程读
            m_idx = i;
            break;
        }
    }
}

template <typename T>
void processpool<T>::setup_sig_pipe() // 统一事件源
{
    m_epollfd = epoll_create(5); // 创建epoll事件监听表和信号管道
    assert(m_epollfd != -1);

    int ret = socketpair(PF_UNIX, SOCK_STREAM, 0, sig_pipefd);
    assert(ret != -1);

    setnonblocking(sig_pipefd[1]);
    addfd(m_epollfd, sig_pipefd[0]);

    addsig(SIGCHLD, sig_handler); // 设置信号处理函数
    addsig(SIGTERM, sig_handler);
    addsig(SIGINT, sig_handler);
    addsig(SIGPIPE, SIG_IGN);
}

template <typename T>
void processpool<T>::run() // 父进程中m_idx值为 -1， 子进程中m_idx值 >= 0，判断接下来运行的是父还是子进程的代码
{
    if (m_idx != -1)
    {
        run_child();
        return;
    }
    run_parent();
}

template <typename T>
void processpool<T>::run_child()
{
    setup_sig_pipe();

    int pipefd = m_sub_process[m_idx].m_pipefd[1]; // 每个子进程都通过其在进程池中的序号值m_idx找到与父进程通信的管道
    addfd(m_epollfd, pipefd); // 子进程需要监听管道文件描述符pipefd 因为父进程将通过它通知子进程accept新连接

    epoll_event events[MAX_EVENT_NUMBER];
    T *users = new T[USER_PER_PROCESS];
    assert(users);
    int number = 0; // epoll事件数量
    int ret = -1;

    while (!m_stop)
    {
        number = epoll_wait(m_epollfd, events, MAX_EVENT_NUMBER, -1);
        if ((number < 0) && (errno != EINTR))
        {
            printf("epoll failure\n");
            break;
        }

        for (int i = 0; i < number; i++) // 处理每个事件
        {
            int sockfd = events[i].data.fd;
            if ((sockfd == pipefd) && (events[i].events & EPOLLIN)) // 父进程有数据给子进程
            {
                int client = 0;
                ret = recv(sockfd, (char *)&client, sizeof(client), 0); // 从父子进程之间管道读取数据，结果保存client中读取成功有新客户
                if (((ret < 0) && (errno != EAGAIN)) || ret == 0)
                {
                    continue;
                }
                else
                {
                    struct sockaddr_in client_address;
                    socklen_t client_addrlength = sizeof(client_address);
                    int connfd = accept(m_listenfd, (struct sockaddr *)&client_address, &client_addrlength);
                    if (connfd < 0)
                    {
                        printf("errno is: %d\n", errno);
                        continue;
                    }
                    addfd(m_epollfd, connfd); // 模板类T必须实现init方法，初始化一个客户连接。我们用connfd来索引处理的逻辑对象 提高效率
                    users[connfd].init(m_epollfd, connfd, client_address); // 实现在cgi_server.cpp中
                }
            }
            else if ((sockfd == sig_pipefd[0]) && (events[i].events & EPOLLIN)) // 有信号，处理信号
            {
                int sig;
                char signals[1024];
                ret = recv(sig_pipefd[0], signals, sizeof(signals), 0);
                if (ret <= 0)
                {
                    continue;
                }
                else
                {
                    for (int i = 0; i < ret; ++i)
                    {
                        switch (signals[i])
                        {
                        case SIGCHLD: // 回收子进程资源
                        {
                            pid_t pid;
                            int stat;
                            while ((pid = waitpid(-1, &stat, WNOHANG)) > 0)
                            {
                                continue;
                            }
                            break;
                        }
                        case SIGTERM:
                        case SIGINT:
                        {
                            m_stop = true;
                            break;
                        }
                        default:
                        {
                            break;
                        }
                        }
                    }
                }
            }
            else if (events[i].events & EPOLLIN) // 其他数据可读 必然是客户请求到来 调用逻辑处理对象的process方法处理
            {
                users[sockfd].process(); // 还没实现
            }
            else
            {
                continue;
            }
        }
    }

    delete[] users;
    users = NULL;
    close(pipefd);
    //close( m_listenfd ); // 应该由m_listenfd的创建者来关闭，所谓的对象由哪个函数创建，就该由那个函数销毁
    close(m_epollfd);
}

template <typename T>
void processpool<T>::run_parent()
{
    setup_sig_pipe();

    addfd(m_epollfd, m_listenfd);

    epoll_event events[MAX_EVENT_NUMBER];
    int sub_process_counter = 0;
    int new_conn = 1;
    int number = 0;
    int ret = -1;

    while (!m_stop)
    {
        number = epoll_wait(m_epollfd, events, MAX_EVENT_NUMBER, -1);
        if ((number < 0) && (errno != EINTR))
        {
            printf("epoll failure\n");
            break;
        }

        for (int i = 0; i < number; i++)
        {
            int sockfd = events[i].data.fd;
            if (sockfd == m_listenfd)
            {
                int i = sub_process_counter; // 有新连接到来，就采用round robin方式将其分给一个子进程
                do
                {
                    if (m_sub_process[i].m_pid != -1) // 选出空闲进程的进程数组索引
                    {
                        break;
                    }
                    i = (i + 1) % m_process_number;
                } while (i != sub_process_counter);

                if (m_sub_process[i].m_pid == -1)
                {
                    m_stop = true;
                    break;
                }
                sub_process_counter = (i + 1) % m_process_number;
                //send( m_sub_process[sub_process_counter++].m_pipefd[0], ( char* )&new_conn, sizeof( new_conn ), 0 );
                send(m_sub_process[i].m_pipefd[0], (char *)&new_conn, sizeof(new_conn), 0);
                printf("send request to child %d\n", i);
                //sub_process_counter %= m_process_number;
            }
            else if ((sockfd == sig_pipefd[0]) && (events[i].events & EPOLLIN)) // 处理父进程收到的信号
            {
                int sig;
                char signals[1024];
                ret = recv(sig_pipefd[0], signals, sizeof(signals), 0);
                if (ret <= 0)
                {
                    continue;
                }
                else
                {
                    for (int i = 0; i < ret; ++i)
                    {
                        switch (signals[i])
                        {
                        case SIGCHLD:
                        {
                            pid_t pid;
                            int stat;
                            while ((pid = waitpid(-1, &stat, WNOHANG)) > 0)
                            {
                                for (int i = 0; i < m_process_number; ++i)
                                {
                                    if (m_sub_process[i].m_pid == pid) // 如果进程池中第i个子进程退出了，则主进程关闭对应通信管道，并设置m_pid为-1，标记子进程已经退出
                                    {
                                        printf("child %d join\n", i);
                                        close(m_sub_process[i].m_pipefd[0]);
                                        m_sub_process[i].m_pid = -1;
                                    }
                                }
                            }
                            m_stop = true;
                            for (int i = 0; i < m_process_number; ++i)
                            {
                                if (m_sub_process[i].m_pid != -1)
                                {
                                    m_stop = false;
                                }
                            }
                            break;
                        }
                        case SIGTERM:
                        case SIGINT:
                        {
                            printf("kill all the clild now\n"); // 杀了所有子进程
                            for (int i = 0; i < m_process_number; ++i)
                            {
                                int pid = m_sub_process[i].m_pid;
                                if (pid != -1)
                                {
                                    kill(pid, SIGTERM);
                                }
                            }
                            break;
                        }
                        default:
                        {
                            break;
                        }
                        }
                    }
                }
            }
            else
            {
                continue;
            }
        }
    }

    //close( m_listenfd ); // 由创建者关闭  见后文
    close(m_epollfd);
}

#endif

此头文件需要传入cgi模板类以进行实例化线程池。模板代码见下一节。
reference:
linux高性能服务器编程——游双

【C++】线程池模板（纯代码）
尚爱猫的博客
10-15 373
thread_pool.h #ifndef __THREAD_POOL_H #define __THREAD_POOL_H #include <vector> #include <string> #include <pthread.h> using namespace std; class CTask{ protected: string m_strTaskName; //任务名称 void* m_ptrData; //要执行任务的
C++—线程池（附源代码）
最新发布
qq_56896418的博客
08-22 3061
std::atomic 提供了原子操作，适用于需要在多线程环境中进行无锁操作的场景。std::atomic_flag 用于实现低级别的锁机制，如自旋锁。了解内存序是使用原子操作时的一个重要方面，它帮助你控制操作的顺序和可见性，从而确保程序的正确性和效率。
线程模板类(c++)，简化线程创建。
09-19
以前经常用VC编程的时候写的一个线程模板类 可以以类的任何方法作为线程过程启动 之后作为了简化 约定方法必须无返回值 且无参数 thread h总共30多行代码 下载者可随意修改 复制 希望对大家有用 用法示例： #include "thread h" class A{ public: void foo { 作为线程运行的代码 this > } void bar { 以foo方法启动线程 上下文为this thread::run<A> this &A::foo ; } };">以前经常用VC编程的时候写的一个线程模板类 可以以类的任何方法作为线程过程启动 之后作为了简化 约定方法必须无返回值 且无参数 thread h总共30多行代码 下载者可随意修改 复制 希望对大家有用 用法示例： [更多]
简单线程池
weixin_44892764的博客
04-02 231
一个简单线程池 thread_pool.h #ifndef __THREAD_POOL_H #define __THREAD_POOL_H #include <vector> #include <string> #include <pthread.h> using namespace std; //执行任务的类:设置任务数据并执行 class CTask {...
详细注释：简单明了的C++线程池模板
凝视阳光呦
09-23 423
网上分享的基本上是属于纯模板的。不利于新手学习，之前在看视频写项目的时候老师也是用的这个模板。虽然很好，用到的都是可变参数，匿名表达式，和其他一些函数。后来自己到github上找到了一个C++版本的。稍作修改。弄了一个模板。算是比较简洁的 线程池需要的： 1.线程池的h和cpp文件(线程池创建，运行，添加任务，唤醒线程工作，销毁） 2.任务的h和cpp文件，(任务类型的创建，任务需要做的事),这里...
2.模板线程池
zhang_int_int的专栏
07-03 712
1.说明 接触多线程已经有较长一段时间了，在工作中也经常用到多线程线程池等，于是打算写一个通用的模板类，方便以后的调用。当开始写的时候，我觉得这应该比较easy，能够很快的实现。而在写的过程中才发现不是那么容易。 这篇文档有模板的相关内容：http://blog.youkuaiyun.com/lqk1985/article/details/3136364 1、首先考虑到的是通用性，怎样让这个多线程通用呢？
【c++池技术】之线程池
distant_Rove666的博客
06-29 997
【c++池技术】之线程池
c++线程池原理和应用
明夷TEC的博客
04-08 1008
文章目录1.线程池2.线程池作用及应用场合3. 线程池实例 1.线程池 线程池是在应用程序启动之后，将立即创建一定数量的线程(N1)，放入空闲队列中。这些线程都是处于阻塞（Suspended）状态，不消耗CPU，但占用较小的内存空间。当任务到来后，缓冲池选择一个空闲线程，把任务传入此线程中运行。当N1个线程都在处理任务后，缓冲池自动创建一定数量的新线程，用于处理更多的任务。在任务执行完毕后线程也...
C++ 线程池源码+demo _android源码分析
01-19
本资源包含针对C++不同版本实现的线程池源码，包括C98、C03和C11版本，以及相关的测试用例，这对于理解和实践C++线程池编程是非常有价值的。 首先，我们来看C98版本的线程池。C++98标准虽然没有内置线程库，但可以...
C++线程池的实现
weixin_47326789的博客
02-22 1106
线程池是一种并发编程的技术，用于管理线程资源。线程池需要先预先创建一定数量的线程，当有任务进来的时候，这些线程会去执行对应的任务。当没有任务的时候，线程会在线程池中进行等待，直到有任务进来。线程池的主要目的是避免反复创建和销毁线程的开销，以及有效地控制并发线程的数量。通过使用线程池，可以降低系统的负载，并提高任务执行的效率。当频繁的进行线程的创建和销毁的时候，可以考虑用线程池进行代替。
linux下线程池的C++模板实现
01-12
这是一个在linux下实现的线程池，利用了C++的模板，可以很容易复用，实现自己的功能开发。
c++ 线程池 即用版
12-21
用c++ 实现的线程池工程，可直接使用，其中线程数目可根据空闲情况自增减，并且实现线程跟任务无关联。
线程池模板 (可以让你快速地使用线程池技术) 帮助你学习线程池
06-16
线程池模板 (可以让你快速地使用线程池技术) 帮助你学习线程池
epoll+线程池
06-12
Linux + C + Epoll实现高并发服务器，运用线程池技术。
Linux + C + Epoll实现高并发服务器(线程池 + 数据库连接池)
热门推荐
旧路
09-27 2万+
Linux 下面用C语言实现的高并发服务器程序，主要用到的是Epoll，线程池，数据库连接池。
901-基于可变参模板实现的线程池(基础知识梳理)
LINZEYU666的博客
12-06 2602
并发和并行 CPU单核 CPU多核、多CPU 并发 单核上，多个线程占用不同的CPU时间片，物理上还是串行执行的，但是由于每个线程占用的CPU时间片非常短（比如10ms），看起来就像是多个线程都在共同执行一样，这样的场景称作并发（concurrent）。 并行 在多核或者多CPU上，多个线程是在真正的同时执行，这样的场景称作并行（parallel）。 多线程的优势 多线程程序一定就好吗？不一定，要看具体的应用场景： IO密集型 （涉及I/O操作） 无论是CPU单核、CPU多核、多CPU，都是比较适合多线
c++模板线程池解读
ninesnow_c的博客
08-11 593
前言 本篇文章是我个人在阅读一个模板线程池适合遇到的困惑，了解c++11一些特性后总算是能看懂了，虽然C++11新特性不难，但是结合模板用起来会比较蒙的。 线程池代码 线程池代码来自github上，链接在这里 #ifndef THREAD_POOL_H #define THREAD_POOL_H #include <vector> #include <queue> #include <memory> #include <thread> #include &l
C++线程池
刺猬先生
01-21 3457
复制这位同学：https://blog.youkuaiyun.com/liushengxi_root/article/details/83932654 1.概述：什么是线程池 因为程序边运行边创建线程是比较耗时的，所以我们通过池化的思想：在程序开始运行前创建多个线 程，这样，程序在运行时，只需要从线程池中拿来用就可以了．大大提高了程序运行效率。 2.如何实现线程池 一般线程池都会有以下几个部分构成： 线程池...
c++实现线程池
tonny的博客
09-05 2733
c++实现线程池
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值