C++自定义实现线程池

最新推荐文章于 2024-07-01 20:36:40 发布
最新推荐文章于 2024-07-01 20:36:40 发布
阅读量303 收藏 2
点赞数
分类专栏： C++ 文章标签： 开发语言 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hdsHDS6/article/details/125156872
版权

本C++线程池由C语言版改编而来

1.任务执行类或结构体

线程池中的线程主要执行的对象

/**
 * 任务类
*/
class Task{
public:
    void (*func)(void* arg);
    void* arg;
};

2.线程池类或结构体

线程池类中的成员属性

// 线程池类或结构体
class ThreadPoolAttr{
public:
    Task* taskQueue; // 任务队列
    int queueCapacity; // 任务队列容量
    int queueSize;   // 任务队列当前大小
    int front; // 入队下标
    int rear;  // 出队下标
    pthread_t managerId; // 管理者线程数量
    pthread_t *wordThreadIDs; // 工作线程
    int wtMinNum; // 工作线程最小数量  
    int wtMaxNum; // 工作线程最大数量
    int wtCurNum; // 当前线程数量
    int wtbusyNum; // 处于工作中的线程数量
    int wtExitNum; // 需要清除的线程数量
    bool is_exit; // 退出标志
    pthread_mutex_t mutexPool; // 线程池互斥变量
    pthread_mutex_t mutexBusy; 
    pthread_cond_t condEmpty;  // 任务队列为空，组塞
    pthread_cond_t condFull;   // 任务队列满了，阻塞
};

3.完整代码

#include <iostream>
using namespace std;
#include <pthread.h>
#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>
#include <unistd.h>
#define EMPTY_STATE 0
#define REDUCE_THREAD 2 // 每次减少两个
#define INCREASE_THREAD 2 // 每次增加两个
#define MAX_THREAD_NUM 20 // 最大线程数
/**
 * 任务类
*/
class Task{
public:
    void (*func)(void* arg);
    void* arg;
};

// 线程池类或结构体
class ThreadPoolAttr{
public:
    Task* taskQueue; // 任务队列
    int queueCapacity; // 任务队列容量
    int queueSize;   // 任务队列当前大小
    int front; // 入队下标
    int rear;  // 出队下标
    pthread_t managerId; // 管理者线程数量
    pthread_t *wordThreadIDs; // 工作线程
    int wtMinNum; // 工作线程最小数量  
    int wtMaxNum; // 工作线程最大数量
    int wtCurNum; // 当前线程数量
    int wtbusyNum; // 处于工作中的线程数量
    int wtExitNum; // 需要清除的线程数量
    bool is_exit; // 退出标志
    pthread_mutex_t mutexPool; // 线程池互斥变量
    pthread_mutex_t mutexBusy; 
    pthread_cond_t condEmpty;  // 任务队列为空，组塞
    pthread_cond_t condFull;   // 任务队列满了，阻塞
};

/**
 * 线程池类
*/
class ThreadPool{
private:
    ThreadPoolAttr* pool;
public:
    /**
     * 构造函数，初始化
     * @param queueCapacity 任务队列容量
     * @param wtMinNum 
     * @param wtMaxNum
     * */ 
    ThreadPool(int queueCapacity, int wtMinNum, int wtMaxNum){
        pool = new ThreadPoolAttr;
        if(pool == NULL){
            cout << "create pool fail" << endl;
            return;
        }
        pool->queueCapacity = queueCapacity;
        pool->wtMinNum = wtMinNum;
        pool->wtMaxNum = wtMaxNum;
        pool->wtCurNum = wtMaxNum;
        pool->queueSize = 0;
        pool->wtbusyNum = 0;
        pool->wtExitNum = 0;
        pool->is_exit = false;
        pthread_mutex_init(&pool->mutexPool, NULL);
        pthread_mutex_init(&pool->mutexBusy, NULL);
        pthread_cond_init(&pool->condEmpty, NULL);
        pthread_cond_init(&pool->condFull, NULL);
        pool->taskQueue = new Task[queueCapacity]; // 创建任务队列数组
        pool->wordThreadIDs = (pthread_t*)malloc(wtMaxNum*sizeof(pthread_t)); // 创建工作线程
        for(int i = 0; i < wtMaxNum; i++){
            pool->wordThreadIDs[i] = 0;
        }
         // 创建管理线程
        pthread_create(&pool->managerId, NULL, manager, pool);
        // 创建工作线程
        for(int i = 0; i < pool->wtMaxNum; i++){
            pthread_create(&pool->wordThreadIDs[i], NULL, worker, pool);
        }

    }
    /**
     * 添加任务
     * @param func  可执行函数
     * @param arg   函数参数
     * */ 
    void addTask(void (*func)(void* arg), void *arg){
        // 加线程池锁
        pthread_mutex_lock(&pool->mutexPool);
        // 任务队列为满状态
        if(pool->queueSize == pool->queueCapacity){
            pthread_cond_wait(&pool->condFull, &pool->mutexPool); // 队列满则阻塞
        }
        int rear = pool->rear;
        pool->taskQueue[rear].func = func;
        pool->taskQueue[rear].arg = arg;
        pool->queueSize++; // 现存任务数量加1
        pool->rear = (pool->rear+1)%pool->queueCapacity; // 下标后移
        pthread_cond_signal(&pool->condEmpty); // 唤醒不为空
        // 解锁
        pthread_mutex_unlock(&pool->mutexPool);
    }
    /**
     * 释放线程池
    */
    bool release(){
        pool->is_exit = true;
    }
    // 析构函数释放内存
    ~ThreadPool(){
        // if(pool == NULL){
        //     return;
        // }
        for(int i = 0, j = 0; i < pool->wtMaxNum; i++){
            while(pool->wordThreadIDs[i] != 0){
                // j = 0;
                // while(j++ < 10000);
                pthread_join(pool->wordThreadIDs[i], NULL);
            }
        }
        pthread_join(pool->managerId, NULL);
        // 释放任务内存
        if(pool->taskQueue){
            delete pool->taskQueue;
        }
        // 释放线程id内存
        free(pool->wordThreadIDs);
        pthread_mutex_destroy(&pool->mutexPool);
        pthread_mutex_destroy(&pool->mutexBusy);
        pthread_cond_destroy(&pool->condEmpty);
        pthread_cond_destroy(&pool->condFull);
        delete pool;
    }
private:
    // 工作线程的主要作用是将将任务队列中的任务取出，然后执行任务
    static void* worker(void* arg){
        ThreadPoolAttr* pool = (ThreadPoolAttr*)arg; // 类型强转
        while(!pool->is_exit){
            pthread_mutex_lock(&pool->mutexPool);
            if(pool->queueSize == EMPTY_STATE){
                pthread_cond_wait(&pool->condEmpty, &pool->mutexPool); // 队列为空则阻塞
            }
            // 判断是否有退出线程
            if(pool->wtExitNum != 0 || pool->is_exit){
                pthread_t cur_id = pthread_self(); // 获取当前线程id
                for(int i = 0; i < pool->wtMaxNum; i++){
                    if(pool->wordThreadIDs[i] == cur_id){
                        pool->wordThreadIDs[i] = 0;
                        break;
                    }
                }
                if(pool->wtExitNum != 0){
                    pool->wtExitNum--; // 退出量减1
                }
                cout << "线程id:"<< pthread_self() << " 被释放！！！" << endl;
                pthread_mutex_unlock(&pool->mutexPool);
                pthread_exit(NULL);
            }
            int front = pool->front;
            void (*func)(void* func_arg) = pool->taskQueue[front].func;
            void* func_arg = pool->taskQueue[front].arg;
            pool->front = (pool->front + 1)%pool->queueCapacity;
            pool->queueSize--; // 任务总数减1
            pthread_cond_signal(&pool->condFull); // 唤醒满队列
            // 解锁
            pthread_mutex_unlock(&pool->mutexPool);

            pthread_mutex_lock(&pool->mutexBusy);
            pool->wtbusyNum++; // 工作中线程加1
            pthread_mutex_unlock(&pool->mutexBusy);
            func(func_arg); // 执行任务
            pthread_mutex_lock(&pool->mutexBusy);
            pool->wtbusyNum--; // 工作中线程减1
            pthread_mutex_unlock(&pool->mutexBusy);
        }
        return NULL;
    }
    static void* manager(void* arg){
        ThreadPoolAttr* pool = (ThreadPoolAttr*)arg;
        while(1){
            sleep(1);
            pthread_mutex_lock(&pool->mutexPool);
            // cout << "管理线程:" << pthread_self() << endl;
            // 减少线程数量
            if(pool->wtbusyNum*2 < pool->wtCurNum && pool->wtCurNum - REDUCE_THREAD > pool->wtMinNum){
                pool->wtExitNum = REDUCE_THREAD;
                pool->wtCurNum -= REDUCE_THREAD;
                for(int i = 0; i < REDUCE_THREAD; i++){
                    pthread_cond_signal(&pool->condEmpty); // 唤醒空阻塞
                }
            }
            // 增加线程数量
            if(pool->queueSize > pool->wtCurNum && pool->wtCurNum + INCREASE_THREAD <= pool->wtMaxNum){
                int n = INCREASE_THREAD;
                for(int i = 0; i < pool->wtMaxNum; i++){
                    if(pool->wordThreadIDs[i] == 0 && n > 0){
                        pthread_create(&pool->wordThreadIDs[i], NULL, worker, pool);
                        n--;
                    }
                    if(n == 0){
                        break;
                    }
                }
                pool->wtCurNum += INCREASE_THREAD; 
            }
            pthread_mutex_unlock(&pool->mutexPool);
            if(pool->is_exit){
                pthread_cond_broadcast(&pool->condEmpty); // 唤醒全部阻塞线程
                pthread_cond_broadcast(&pool->condFull); // 唤醒全部阻塞线程
                break;
            }
        }
        return NULL;
    }
};
void add_test(void* arg){
    cout << "线程id:" << pthread_self() << endl;
    sleep(2);
}
int main()
{
    ThreadPool *threadpool = new ThreadPool(100, 5, 10);
    threadpool->addTask(add_test, NULL);
    threadpool->addTask(add_test, NULL);
    threadpool->addTask(add_test, NULL);
    threadpool->addTask(add_test, NULL);
    threadpool->addTask(add_test, NULL);
    threadpool->addTask(add_test, NULL);
    threadpool->addTask(add_test, NULL);
    threadpool->addTask(add_test, NULL);
    threadpool->addTask(add_test, NULL);
    threadpool->addTask(add_test, NULL);
    threadpool->addTask(add_test, NULL);
    threadpool->addTask(add_test, NULL);
    cout << "Hello World" << endl;
    sleep(10); // 等待10秒 ，注意添加 unistd.h 头文件
    threadpool->release(); // 释放线程池
    delete threadpool;
    return 0;
}

4.执行结果

 

木木夕木目心.HDS
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++实现线程池
静水流深
10-29 740
实现线程池 ✏ 线程池 ???? 1、作用：异步解耦 线程池的运行逻辑：线程池中的线程在不断竞争任务队列中的任务。 ???? 2、组成 任务队列 线程集合 管理组件 ???? 3、TODO 增加线程 删除过度冗余的线程 快手面试题：查询一个任务是否被执行完，生产者消费者模式（任务队列用环形阻塞队列即可） 头条面试题：如果一个任务在执行过程中线程被中断（也许是时钟周期已到，也许是等待资源，也许是被中断，等等），后面怎样保证继续被同一个线程执行。 C-glibc实现 #include <stdi
c++实现线程池
03-06
在C++中，可以通过自定义比较函数对象来实现优先级队列。 6. **线程池的大小**：线程池的大小需要根据系统资源和任务特性来设定，过大可能导致资源浪费，过小则可能无法充分利用多核优势。 7. **异常处理**：...
C++ 线程池
最新发布
暮色尽染的博客
07-01 855
(来自ChatGPT)线程池是一种用于管理和复用线程的机制。它可以提高程序的性能和效率，特别是在处理大量并发任务时。线程池中包含一定数量的线程，这些线程可以重复执行多个任务。当有任务需要执行时，可以将任务提交给线程池，线程池会选择一个可用的线程来执行任务。任务执行完毕后，线程会返回线程池，等待下一个任务的到来。线程池的优点：降低线程创建和销毁的开销：线程的创建和销毁是比较耗费资源的操作，使用线程池可以避免频繁地创建和销毁线程，提高程序的性能。提高系统的响应速度。
自定义c++线程池
n_fly的博客
07-13 294
学习c++有一段时间了，打算从string、线程池、网络等方面入手，写一些东西。期间参考了网络上很多书写线程池得blog。以为是很简单的事，真正着手编程调试的时候确遇到了很多的问题。如：  1）两个类的头文件交叉引用，导致编译通不过的问题。解决方案：抽取出父类，通过继承，解决这个问题。  2)  new出来的对象在回收的时候，引发的一些异常。 3）如何保证线程在对象销毁之前回收。解决方案：在
利用C++语言设计可扩展线程池
小发猫
03-15 1523
　　摘要：在各种业务解决方案的设计中，服务器处理任务的效率是衡量方案优劣的一个重要标准。使用多线程技术并发处理任务是提高服务器效率的一个主要手段。但是频繁的线程创建、销毁和任务的分配也会降低系统效率。本文设计了一个通用的线程池，根据不同服务器所处理的任务的特点，可以设置对应的线程池参数，最大幅度的提高系统性能。　　关键字：线程池多线程任务虚函数异常　　概述　　在各种业务解决方案的设计过程中，服务器
C++线程池实现 vc2015编译
12-24
在这个项目中，我们看到一个用于VC2015编译环境的C++线程池实现。 首先，`stdafx.cpp`和`stdafx.h`是Visual Studio项目中的标准预编译头文件，通常包含常用的库引用和预处理器定义，以提高编译速度。`targetver.h`...
visual c++实现线程池的例子threadpooldemosrc.rar
07-07
在Windows环境下，Visual C++（VC++）提供了多种方式来实现线程池，其中包括使用Microsoft的 ConcRT（Concurrent Runtime）库和自定义实现。这个“threadpooldemosrc.rar”压缩包中的示例代码可能是为了演示如何在...
一种类似JAVA线程池的C++线程池实现方法
08-25
不过，需要注意的是，虽然这种实现借鉴了Java线程池的设计思想，但C++标准库并没有提供内置的线程池实现，因此自定义线程池需要考虑平台兼容性、线程同步、错误处理等问题。此外，对于大型项目，可能还需要考虑...
Threadpool:轻便，快速，适用于C ++ 20的线程池
03-25
riften::Thiefpool 面向C ++ 20的超快速，轻量级，可窃取工作的线程池。 建立在无锁并发 。 用法 # include " riften/thiefpool.hpp " // Create thread pool with 4 worker threads. riften::Thiefpool pool ( 4 ); // Enqueue and return future. auto result = pool.enqueue([]( int x) { return x; }, 42 ); // Get result from future. std::cout << result.get() << std::endl; 另外， riften::Thiefpool提供了分离的入队版本： // Enqueue and return nothing pool.enq
自增减线程池
yiyeqinghuasoon
12-22 386
工作中接手了一款产品的改造。因为该产品可能使用很多线程，所以产品中使用了线程池。 线程池的一个优点是降低线程创建和销毁的频率；缺点是可能在比较闲的时候还存在一定数量的空闲线程。这个也可以比作现实生活中的武器，对于一款武器，有其攻击的能力和防御的能力。有些设计可能会将攻击力做的很强但是防御力有所折扣，有些可能防御做的很好但是攻击力不足。于是如果将这些设计放在一起可能就很难比较个...
c++11自定义线程池
n_fly的博客
07-27 374
为了保证退出程序前，所有运行的线程都已经停止。我引入了信号量，对线程池进行改造。改造实习代码如下。 #pragma once #include #include #include #include #include #include"Semaphore.h" using namespace std; class Thread { public: typedef void(*TheadFunc
C++实现一个线程池
weixin_45131842的博客
04-23 120
使用C++写一个最简单的线程池
C++自定义线程池以及通过线程池处理业务展示
qq_28107929的博客
11-08 721
本实例通过3部分进行展示： 将线程池定义成一个类，用来管理线程，该线程池设计成单例模式 设计了一个工作类，即工作线程类，用于处理业务（使用基于事件的同步方式和原子操作同步方式） 设计了一个任务分发管理类，用于模拟实际业务使用线程池实现处理业务 自定义事件类：.h #pragma once #include&amp;amp;amp;lt;windows.h&amp;amp;amp;gt; class LanEvent { public: La...
使用C++实现一个简单的线程池
Huoon的博客
04-14 2826
线程池类似于内存池，连接池等，在一开始创建好一定数量的线程，当有任务需要处理时，就将该任务丢进线程池的某个线程中处理，而不是每个任务都启动一个线程。使用线程池的好处在于，不需要频繁的创建线程，因为创建线程是一个较耗资源的操作。因此，相对而言一开始创建好线程，要比动态创建线程对性能影响更小。其次，线程池可以更好的将线程管理起来，对外提供简单的接口，内部完成对线程的调度，这也是高内聚的一个思想，将复杂封装起来，对外在满足业务场景的前提下尽可能简单。线程池作为一个独立的非业务模块，任何需要处理多任务的场景都可以使
九、Linux系统编程：线程池编程
小脑斧的博客
05-26 221
线程池编程
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值