devbox
很楠不爱3
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

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

作者：很楠不爱3 | 2024-05-25 11:05:17

赞

踩

c++线程池原理

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);

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57

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;
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127
  • 128
  • 129
  • 130
  • 131
  • 132
  • 133
  • 134
  • 135
  • 136
  • 137
  • 138
  • 139
  • 140
  • 141
  • 142
  • 143
  • 144
  • 145
  • 146
  • 147
  • 148
  • 149
  • 150
  • 151
  • 152
  • 153
  • 154
  • 155
  • 156
  • 157
  • 158
  • 159
  • 160
  • 161
  • 162
  • 163
  • 164
  • 165
  • 166
  • 167
  • 168
  • 169
  • 170
  • 171
  • 172
  • 173
  • 174
  • 175
  • 176
  • 177
  • 178
  • 179
  • 180
  • 181
  • 182
  • 183
  • 184
  • 185
  • 186
  • 187
  • 188
  • 189
  • 190
  • 191
  • 192
  • 193
  • 194
  • 195
  • 196
  • 197
  • 198
  • 199
  • 200
  • 201
  • 202
  • 203
  • 204
  • 205
  • 206
  • 207
  • 208
  • 209
  • 210
  • 211
  • 212
  • 213
  • 214
  • 215
  • 216
  • 217
  • 218
  • 219
  • 220
  • 221

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;
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28

部分运行结果
（注意：在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替代
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/很楠不爱3/article/detail/621775
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号