C/C++ 线程池工作原理 & C代码实现

已于 2023-07-11 20:33:41 修改
阅读量1k 收藏 14
点赞数 3
分类专栏： C/C++ 文章标签： c语言 c++ 多线程 线程池 C/C++ linux 操作系统
于 2023-06-29 19:18:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42785590/article/details/131462098
版权

1. 线程池作用

如果多次使用线程，那么就需要多次的创建并撤销线程。但是创建/撤销的过程会消耗资源。线程池是一种数据结构，其中维护着多个线程，这避免了在处理短时间任务时，创建与销毁线程的代价。即在程序开始运行前预先创建一定数量的线程放入空闲队列中，这些线程都是处于阻塞状态，基本不消耗CPU，只占用较小的内存空间，程序在运行时，只需要从线程池中拿来用就可以了，大大提高了程序运行效率。

2. 线程池结构

线程池基本结构

任务结构体

  • 任务函数地址：任务本身就是让线程执行的函数，这里存函数指针
  • 任务函数参数：函数的参数，使用void*类型万能转换

线程池结构体

  • 任务相关
    • 任务队列：存储当前线程池中的任务，C语言中使用任务结构体的数组来存
    • 最大任务数量 ：队列中可以排队的最大任务数量
  • 工作线程相关：
    • 线程ID数组：存储工作的线程，长度为最大线程数量
    • 最小线程数量：线程池中存活的最小线程数量
    • 最大线程数量：线程池中存活的最大线程数量
    • 活跃线程数：当前存活线程数，可以作为管理线程工作的依据
    • 当前忙碌线程数：当前正在处理任务的线程数量，可以作为管理线程工作的依据
  • 管理相关：
    • 管理线程ID：管理线程的线程ID，管理线程根据当前任务数量、活跃线程数、忙碌线程数来判断是否需要增加/减少线程池中线程的数量，这样可以最大化利用系统资源。
    • 剩余删除的线程数量：每次需要删除线程时，管理线程会给当前变量赋值，这样工作线程如果判断该变量不为0，则工作线程自发exit
    • 销毁线程flag：判断是否要销毁整个线程池，初始化为0，为1时销毁。
  • 锁相关
    • 线程池临界资源互斥锁：
    • 多线程共享线程池中临界资源时，需要使用互斥锁进行线程同步
    • 任务队列满条件锁：任务队列满的时候，如果还有新的任务需要添加，则需要wait阻塞等待；同时每次工作线程取出一个任务，还需要signal操作来解除阻塞
    • 任务队列空条件锁：任务队列空的时候，工作线程拿任务的操作需要被阻塞；同时每次用户添加了一个任务，还需要signal操作来解除阻塞

线程工作函数

  • 工作线程工作函数：用于控制工作线程的工作流程，阻塞式从任务队列中拿任务并执行。还需要响应删除线程、销毁线程池的操作。
  • 管理线程工作函数：用于控制管理线程的工作流程，循环检测并控制当前线程池中线程的数目。还需要响应销毁线程池的操作

用户接口：

  • 新建线程池：新建一个线程池，需要指定最大线程数，最小线程数，任务队列长度
  • 添加任务：向线程池中添加一个任务
  • 销毁线程池：销毁线程池并释放资源
  • 查看当前任务数量：返回任务队列中任务的数量
  • 查看当前线程数量：返回当前存活线程数量
  • 查看当前忙线程数量：返回当前忙碌线程数量

3. C语言实现代码及注释

3.1 结构概述：

  • myThreadPool.h：定义线程池的结构体，并声明相关函数
  • myThreadPool.c：实现MyThreadPool中的声明的函数
  • main.c：测试代码

3.2 myThreadPool.h 头文件

#include <stdio.h>
#include<pthread.h>
#include<unistd.h>
typedef struct Task{ //任务结构体
    void (*function) (void *arg); //函数指针
    void* arg; //函数的参数
}Task;
typedef struct threadPool{
    
    //任务相关
    Task *task; //任务队列的指针
    int taskMaxNum; //任务队列的最大长度
    int taskNum; //任务数量
    int head; //任务队列的队头，C语言没有queue，需要手写queue
    int tail; //任务队列的队尾
    
    //普通线程相关
    pthread_t *workId; //线程数组的指针
    int minNum; //线程池最小线程数，用户指定
    int maxNum; //线程池最大线程数，用户指定
    int liveNum; //线程池当前存活线程数
    int busyNum; //线程池当前忙碌线程数，作为是否需要增加/减少线程数量的依据
    
    //管理线程相关
    pthread_t manageId;
    int deleteNum; //线程太多时，每一次要取消的线程数量
    int shutDown; //判断线程池是否要销毁，1表示要销毁
    
    //锁相关
    pthread_mutex_t mutexPool; //互斥锁，锁住整个线程池
    pthread_cond_t condFull; //条件锁，任务队列满了则阻塞，用于添加任务
    pthread_cond_t condEmpty; //条件锁，任务队列空了则阻塞，用于取出任务
    
}threadPool;
//普通线程工作函数
void* worker(void* arg);

//管理线程工作函数
void* manager(void* arg);

//新建线程池
threadPool* createPool(int minNum, int maxNum, int taskMaxNum);

//添加任务,pool表示线程池，task表示任务的函数指针，arg表示函数的参数
int addtask(threadPool *pool, void (*func)(void*), void* arg);

//查看线程数量
int getThreadNum(threadPool *pool);

//查看忙线程数量
int getBusyThreadNum(threadPool *pool);

//查看任务数量
int getTaskNum(threadPool *pool);

//销毁线程池
int deletePool(threadPool *pool);

3.3 myThreadPool.c 函数实现

#include<stdio.h>
#include "C-myThreadPool.h"
#include<stdlib.h>

// 普通线程工作函数，每次从任务队头取出任务并执行，如果没有任务则阻塞，参数为线程池
void* worker(void* arg){
    threadPool* pool = (threadPool *)arg;
    
    //循环执行
    while(1){
        pthread_mutex_lock(&pool->mutexPool);//上锁，线程池为临界资源，需要进行线程同步
        
        //销毁线程池
        if(pool->shutDown){
            pthread_mutex_unlock(&pool->mutexPool);
            pthread_exit(NULL);
        }
        
        //线程终止，即管理线程中设置了要取消的线程deleteNum的值，让空闲的线程自己自杀
        while(pool->deleteNum>0){ //deleteNum大于0
            pool->deleteNum--;
            pool->liveNum--;
            pthread_mutex_unlock(&pool->mutexPool);
            for(int i=0;i<pool->maxNum;++i){ //找到当前线程
                if(pool->workId[i] == pthread_self()){
                    pool->workId[i] = 0; //重置线程池中线程数组的编号，0表示空闲
                }
            }
            pthread_exit(NULL); //终止当前线程
        }
       
        
        //从任务队列中取出任务，并执行
        int taskNum = pool->taskNum;
        
        while(!pool->shutDown && taskNum==0){ // 如果当前没有任务
            pthread_cond_wait(&pool->condEmpty, &pool->mutexPool); // 阻塞等待
        }
        
        //如果在等待任务的时候，客户端调用销毁线程池，则需要再次判断一次
        if(pool->shutDown){
            pthread_mutex_unlock(&pool->mutexPool);
            pthread_exit(NULL);
        }
        
        Task task;
        task.function= pool->task[pool->head].function; //取出任务队列头结点
        task.arg = pool->task[pool->head].arg;
        pool->head = (++pool->head) % pool->taskMaxNum; //头结点后移，%操作模拟队列
        pool->taskNum--;  //任务数量-1
        pthread_mutex_unlock(&pool->mutexPool); // 解锁
        
        pthread_cond_signal(&pool->condFull); //对该条件锁解锁，这样如果任务队列满了，告诉生产者就可以生产任务了
        
        printf("thread %ld begin working\n", (long)pthread_self());
        task.function(task.arg); //执行任务
        pthread_mutex_lock(&pool->mutexPool); //上锁
        pool->busyNum++;
        pthread_mutex_unlock(&pool->mutexPool); // 解锁
        
        printf("thread %ld end working\n", (long)pthread_self());
        pthread_mutex_lock(&pool->mutexPool); //上锁
        pool->busyNum--;
        pthread_mutex_unlock(&pool->mutexPool); // 解锁
    }
    return NULL;
}

// 管理线程工作函数
void* manager(void* arg){
    
    threadPool* pool = (threadPool *)arg;
    
    while(!pool->shutDown){  //如果线程池没有被销毁
        
        sleep(5);//每隔5秒检测一次
        
        pthread_mutex_lock(&pool->mutexPool);
        int liveNum = pool->liveNum;
        int taskNum = pool->taskNum;
        pthread_mutex_unlock(&pool->mutexPool);
        
        //如果存活的线程太少，则增加线程，每次增加2个
        if(taskNum > liveNum && liveNum < pool->maxNum)
        {
            pthread_mutex_lock(&pool->mutexPool);
            int num=0; //已经增加的线程数量，假设每次增加2个线程
            for(int i=0;i<pool->maxNum && num<2 && pool->liveNum<pool->maxNum; ++i){
                if(pool->workId[i]==0){
                    pthread_create(&pool->workId[i], NULL, worker, pool); //新建线程
                    num++;
                    pool->liveNum++;
                }
            }
            pthread_mutex_unlock(&pool->mutexPool);
            printf("2 threads are added by manager\n");
        }
        
        //如果存活的线程太多，则减少线程，每次减少2个
        if(taskNum*2 < liveNum && liveNum > pool->minNum)
        {
            pthread_mutex_lock(&pool->mutexPool);
            if(pool->liveNum-2 >= pool->minNum)pool->deleteNum=2;  //这里不能指定杀死某个线程，因为并不知道线程的状态，要让空闲的线程自己自杀
            pthread_mutex_unlock(&pool->mutexPool);
            printf("2 threads are deleted by manager\n");
        }
    }
    
    return NULL;
}

// 新建线程池
threadPool* createPool(int minNum, int maxNum, int taskMaxNum){
    
    // 任务相关
    threadPool *pool = (threadPool*)(malloc(sizeof(threadPool)));
    pool->task = (Task*)(malloc(sizeof(Task)*taskMaxNum));
    pool->taskMaxNum = taskMaxNum;
    pool->head = 0;
    pool->tail = 0;
    
    // 普通线程相关
    pool->workId = (pthread_t *)(malloc(sizeof(pthread_t)*maxNum));
    pool->minNum = minNum;
    pool->maxNum = maxNum;
    pool->liveNum = 3;
    pool->busyNum = 0;
    for(int i=0;i<pool->maxNum;++i){
        pool->workId[i]=0;  // 初始化id均为0，0表示该位置没有对应的线程
    }
    for(int i=0;i<pool->minNum;++i){ // 开始启动最小数量的线程
        pthread_create(&pool->workId[i], NULL, worker, pool);
    }
    
    // 管理线程相关，直接启动管理线程
    pthread_create(&pool->manageId, NULL, manager, pool);
    pool->deleteNum = 1; // 每次取消一个线程
    pool->shutDown = 0;
    
    // 锁相关
    pthread_mutex_init(&pool->mutexPool, NULL);
    pthread_cond_init(&pool->condFull, NULL);
    pthread_cond_init(&pool->condEmpty, NULL);
    
    
    return pool; //pool在共享堆内存，所以不会自动释放
}

//添加任务,pool表示线程池，task表示任务的函数指针，arg表示函数的参数
int addtask(threadPool *pool, void (*func)(void*), void* arg){
    
    pthread_mutex_lock(&pool->mutexPool); //加锁
    
    //任务队列满了，则阻塞等待
    while(pool->taskNum == pool->taskMaxNum && !pool->shutDown){
        pthread_cond_wait(&pool->condFull, &pool->mutexPool);
    }
    if(pool->shutDown){
        pthread_mutex_unlock(&pool->mutexPool);
    }
    
    
    pool->task[pool->tail].function = func;
    pool->task[pool->tail].arg = arg;
    pool->taskNum++;
    pool->tail = (++pool->tail) % pool->taskMaxNum; //任务队列尾部向后移动1
    pthread_cond_signal(&pool->condEmpty); //对该条件变量进行解锁，这样等待的线程可以拿任务了
    
    pthread_mutex_unlock(&pool->mutexPool);
    
    return 0;
}

//查看线程数量
int getThreadNum(threadPool *pool){
    pthread_mutex_lock(&pool->mutexPool); //读加锁是为了防止极端情况：读了一半然后被其它线程修改
    int liveNum = pool->liveNum;
    pthread_mutex_unlock(&pool->mutexPool);
    return liveNum;
}

//查看忙线程数量
int getBusyThreadNum(threadPool *pool){
    pthread_mutex_lock(&pool->mutexPool); //读加锁是为了防止极端情况：读了一半然后被其它线程修改
    int BusyThreadNum = pool->busyNum;
    pthread_mutex_unlock(&pool->mutexPool);
    return BusyThreadNum;
}

//查看任务数量
int getTaskNum(threadPool *pool){
    pthread_mutex_lock(&pool->mutexPool); //读加锁是为了防止极端情况：读了一半然后被其它线程修改
    int taskNum = pool->taskNum;
    pthread_mutex_unlock(&pool->mutexPool);
    return taskNum;
}

// 销毁线程池
int deletePool(threadPool *pool){
    if(pool==NULL){
        return -1; // 如果线程池已经不存在了，则返回-1
    }
    pool->shutDown=1;
    pthread_join(pool->manageId, NULL); //阻塞回收管理子线程
    for(int i=0;i<pool->maxNum;++i) //唤醒所有等待任务的普通子线程
        pthread_cond_broadcast(&pool->condEmpty);
    
    //释放pool中的两个堆内存
    if(pool->task)free(pool->task);
    if(pool->workId) free(pool->workId);
    
    //回收锁
    pthread_mutex_destroy(&pool->mutexPool);
    pthread_cond_destroy(&pool->condFull);
    pthread_cond_destroy(&pool->condEmpty);
    
    //回收线程池
    free(pool);
    pool=NULL;
    return 0;
}

3.4 main.c 测试代码

#include <stdio.h>
#include <stdlib.h>
#include "C-myThreadPool.h"

void test_task(void *arg){
    int num = *(int*)arg;
    printf("thread %ld is working, number = %d\n", (long)pthread_self(), num);
    sleep(1);
}
int main(int count, char** arg){  //测试代码
    
    threadPool* pool =createPool(3, 10, 50);
    for(int i=0;i<100;++i){
        int *num = (int*)malloc(sizeof(int));
        *num = i;
        addtask(pool, test_task, num);
    }
    
    //每两秒检测一次，如果还存在任务或者忙的线程，则等待
    while( getTaskNum(pool) || getBusyThreadNum(pool) ){
        sleep(2);
    }
    
    //销毁线程池
    deletePool(pool);
    return 0;
}

部分运行结果
（注意：在linux命令行下运行gcc，需要 -l 指定链接的库文件pthread，执行 gcc main.c -l pthread -o output即可）
在这里插入图片描述

4. 总结

  • 本代码中可能有些地方存在不足
    • 如有些地方可能没有free堆内存
    • 没有考虑空间分配失败的情况，如果考虑，可以在每次申请内存的时候判断即可
  • C语言中由于没有对象的概念，并且没有STL容器，所以很多结构都需要自己手写，比较麻烦，并且没有封装成一个类，看起来结构性不强。
  • C语言改C++：
    • 可以将结构体和相关函数都封装在一个线程池类中
    • 表示线程可以使用C++11中的线程类std::thread
    • 任务队列可以使用STL中的queue
    • 存工作线程的数组，可以使用STL中的vector替代
98kai
关注
  • 3
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++线程池实现原理
01-20
背景 　　多线程编程是C++开发者的一个基本功， 但是很多开发者都是直接使用公司给包装好的线程池库， 没有去了解具体实现，有些实现也都因为高度优化而写得讳莫如深，让初学者看得吃力。 　　所以写这篇文章主要是想以非常简单的方式讲讲实现原理， 希望初学者看完之后不是觉得「不明觉厉」，而是觉得「原来如此」。 　　面朝代码 　　首先先来一段超级简单（注释丰富）的代码展示多线程编程的经典写法。 　　注: 该段代码和完整运行示例请见 limonp-thread-pool-programming-example ， 可以通过以下命令跑通示例代码和输出结果，建议尝试以下。当然记得前提是该机器的网络可
线程池原理及创建（C++实现）
08-27
线程池原理及创建（C++实现）线程池原理及创建（C++实现）线程池原理及创建（C++实现）线程池原理及创建（C++实现）
C语言/C++基础之跨年烟花代码
12-20
C语言/C++基础之跨年烟花代码，适合初学C语言/C++的小伙伴学习研究，博客中有对应的讲解和演示，避免走弯路，费时费力。也真心希望能够帮助正在苦学C语言/C++ 程序设计的小伙伴们，你们的成长是我最大的幸福
基于C语言/C++基础的跨年烟花代码
12-19
C语言/C++基础之跨年烟花代码，适合初学C语言/C++的小伙伴学习研究，博客中有对应的讲解和演示，避免走弯路，费时费力。也真心希望能够帮助正在苦学C语言/C++ 程序设计的小伙伴们，你们的成长是我最大的幸福
C语言/C++ 烟花表白代码
10-13
C语言/C++ 烟花表白代码 C语言/C++ 烟花表白代码 C语言/C++ 烟花表白代码 C语言/C++ 烟花表白代码
线程池 c语言
weixin_60208935的博客
09-23 4146
本文旨在纯c实现线程池。线程池线程池是一种多线程处理形式，处理过程中将任务添加到队列，然后在创建线程后自动启动这些任务。
c++实现线程池
tonny的博客
09-05 2385
c++实现线程池
C语言简易线程池实现
m0_58966334的博客
04-17 471
【代码】C语言简易线程池实现
【用C语言实现线程池】
qq_43899283的博客
04-27 5548
用C语言实现线程池线程池原理线程池的组成结构任务队列工作的线程管理者线程代码实现 线程池原理   我们使用线程的时候就去创建一个线程，这样实现起来非常简便，但是就会有一个问题：如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低系统的效率，因为频繁创建线程和销毁线程需要时间。   那么有没有一种办法使得线程可以复用，就是执行完一个任务，并不被销毁，而是可以继续执行其他的任务呢？   线程池是一种多线程处理形式，处理过程中将任务添加到队列，然后在创建线程后自动启
用C语言实现一个线程池
weixin_61180235的博客
04-10 518
上述代码中，先定义了一个任务结构体和一个线程池结构体，分别用于存储任务的执行函数和参数，以及线程池中的相关信息。在初始化线程池时，会创建指定数量的线程，并将其加入到线程池中，并创建一个任务队列。添加任务时，需要使用加锁操作保证多线程安全，并将任务加入到队列中，并唤醒空闲线程开始执行任务。每个工作线程从任务队列中取出一个任务并执行，如果队列为空则等待通知。在销毁线程池时，会等待所有任务执行完毕后终止所有线程并释放占用的资源。
C/C++中*和&的用法详解
12-26
C++中&和*的用法一直是非常让人头疼的难点，课本博客上讲这些知识点一般都是分开讲其用法的，没有详细的总结，导致我在这方面的知识结构格外混乱，在网上找到了一篇英文文章简单总结了这两个符号的一些用法，都是一些比较基础的知识，我比较关心的函数指针，指针函数等都没有涉及到，今后有时间把这部分学明白整理出来。 C/C++中*和&的用法 C++语言是C语言的超集。几乎所有可以运行的C程序都是可以运行的C++程序。因此，写一个不包含C++特性的C++程序是可能的，尽管cout和引用的使用（见下文）更好的构成了一个C++程序。C++和C在代码格式上偶尔会有不同，比如，在C语言中，我们这样把p声明为一个int
C语言/C++基础之实现绕线画代码
12-20
C语言/C++基础之实现绕线画代码，适合初学C语言/C++的小伙伴学习研究，博客中有对应的讲解和演示，避免走弯路，费时费力。也真心希望能够帮助正在苦学C语言/C++ 程序设计的小伙伴们，你们的成长是我最大的幸福
C 语言编程 — 线程池设计与实现
烟云的计算
03-14 1222
Thread Pool 会在 User Process 中预先创建一组 User Threads，并在需要时重复使用它们，而不是频繁的创建新线程。当有 Task 需要处理时，Manager 就从 Pool 中获取一个可用的 Thread 来处理这个 Task。：用于管理 Thread Pool 资源：例如：多线程、互斥锁、条件变量等。：分配来真正处理 Task 的 Worker Thread（工作线程）。C-Thread-Pool 是一个开源的轻量级线程池，实现了以下功能。
线程池代码的C实现以及在各种开源框架中的使用
thunderLZM的博客
09-19 756
线程池的本质是对任务和线程的管理，而做到这一点最关键的思想就是将任务和线程两者解耦，不让两者直接关联，才可以做后续的分配工作。在一个事件循环中，可以处理多个就绪事件，这些就绪时间在reactor模型中时串行执行的，一个事件处理延时若耗时较长，会延迟其它同时触发的事件的处理（对于客户端而言，响应会变得较慢）。对于线程，内存，oracle的连接对象等等，这些都是资源，程序中当你创建一个线程或者在堆上申请一块内存时，都涉及到很多系统调用，也是非常消耗CPU的，，内存池，连接池，对象池等等。2、线程池的使用场景。
线程池的工作原理及C++实现
Jiangtagong的博客
08-17 1919
本文的笔记来自于b站视频的爱编程的大丙，博客链接：https://subingwen.cn/，有做了相应的补充！ 一、线程池的原理 线程池是一种多线程处理的形式，处理过程中将任务添加到队列，任何在创建线程后自动启动这些任务。线程池线程都是后台线程。每个线程都使用默认的堆栈大小，以默认的优先级运行，并处于多线程单元中。如果某个线程在托管代码中空闲（如正在等待某个事件的发生），则线程池将插入另外一个辅助线程来使所有处理器保持繁忙。如果所有线程池线程始终保持繁忙，但队列中包含挂起的工作，则线程池将在一段..
【线程池】的原理分析及源码（C语言版）
m0_62140641的博客
12-11 267
**任务结构体 *//// 泛型，兼容各种各样的数据类型void *arg;} Task;/** 线程池的结构体*//** 任务队列*/// 容量// 当前任务个数// 队头// 对尾// 管理者线程ID// 工作的线程IDint minNum;// 最小的线程数int maxNum;// 最大的线程数// 正在工作的线程// 存活的线程个数// 要销毁的线程个数///< 锁整个线程池///< 锁busyNum变量///< 任务队列是不是满了。
C++线程池的实现
zhc的博客
05-07 2127
池式结构 在计算机体系结构中有许多池式结构：内存池、数据库连接池、请求池、消息队列、对象池等等。 池式结构解决的主要问题为缓冲问题，起到的是缓冲区的作⽤。 线程池 通过使⽤线程池，我们可以有效降低多线程操作中任务申请和释放产⽣的性能消耗。特别是当我们每个线程的任务处理⽐较快时，系统 ⼤部分性能消耗都花在了pthread_create以及释放线程的过程中。那既然是这样的话，何不在程序开始运⾏阶段提前创建好⼀堆线程，等 我们需要⽤的时候只要去这⼀堆线程中领⼀个线程，⽤完了再放回去，等程.
C++线程编程-各种线程池
NINE_world的博客
04-09 1031
线程池 存放任务的线程安全队列 // 对比4.5 使用条件变量的线程安全队列的完整类定义 // 包含shared_ptr实例 #include <condition_variable> #include <mutex> #include <queue> #include <utility> #include <memory> template <typename T> class threadsafe_queue { private:
C语言 | Leetcode C语言题解之第45题跳跃游戏II
最新发布
m0_59237910的博客
04-23 364
C语言 | Leetcode C语言题解之第45题跳跃游戏II
如何实现线程池并用c/c++举例说明
06-07
C/C++中可以通过pthread库来实现线程池。下面是一个简单的C++线程池实现的代码示例： ```cpp #include <iostream> #include <pthread.h> #include <queue> using namespace std; class ThreadPool { public: ThreadPool(int size) { this->size = size; threads = new pthread_t[size]; for (int i = 0; i < size; i++) { pthread_create(&threads[i], NULL, worker, this); } } void addTask(void (*task)(void*), void* arg) { pthread_mutex_lock(&mutex); tasks.push(make_pair(task, arg)); pthread_mutex_unlock(&mutex); } void waitAll() { for (int i = 0; i < size; i++) { pthread_join(threads[i], NULL); } } private: static void* worker(void* arg) { ThreadPool* pool = static_cast<ThreadPool*>(arg); while (true) { pthread_mutex_lock(&pool->mutex); if (pool->tasks.empty()) { pthread_mutex_unlock(&pool->mutex); break; } auto task = pool->tasks.front(); pool->tasks.pop(); pthread_mutex_unlock(&pool->mutex); task.first(task.second); } return NULL; } int size; pthread_t* threads; queue<pair<void (*)(void*), void*>> tasks; pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; }; void task(void* arg) { int* num = static_cast<int*>(arg); cout << "Task #" << *num << " is running." << endl; delete num; } int main() { ThreadPool pool(5); for (int i = 0; i < 10; i++) { int* num = new int(i); pool.addTask(task, num); } pool.waitAll(); return 0; } ``` 上面的代码使用了pthread库来创建线程池，并通过addTask方法将任务添加到线程池的任务队列中。执行结果如下： ``` Task #0 is running. Task #1 is running. Task #2 is running. Task #3 is running. Task #4 is running. Task #5 is running. Task #6 is running. Task #7 is running. Task #8 is running. Task #9 is running. ``` 这里的任务只是简单地输出了一条信息，实际上可以根据需要编写自己的任务逻辑，利用线程池提高程序的执行效率和稳定性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值