【c++池技术】之线程池C版

编程远泊

已于 2023-07-03 21:43:17 修改

阅读量875

点赞数 5

分类专栏： cpp 文章标签： c++ c语言池技术

于 2023-06-28 21:43:03 首次发布

本文链接：https://blog.csdn.net/distant_rove666/article/details/131445456

版权

cpp 专栏收录该内容

12 篇文章 1 订阅

订阅专栏

什么是线程池

线程池是一种多线程处理形式，它在程序启动时创建多个线程，放入一个池（即容器）中，程序员可以直接从线程池中取出线程来使用，而不必每次需要使用线程时都创建线程。线程池中的线程在完成当前任务后不会立即销毁，而是可以继续存活并执行其他任务。

线程池的主要优点有：

重用线程：线程池中的线程可以被多次重用，避免了频繁创建和销毁线程所带来的性能开销。
控制并发线程数：线程池可以限制系统中并发线程的数量，防止系统因为线程数量过多而过载。
管理线程：线程池提供了一种方便的线程管理机制，可以方便地实现线程的调度和控制。

线程池的基本工作原理是：当有新的任务到来时，线程池会先检查池中是否有空闲的线程，如果有，就直接使用这个线程来执行任务；如果没有，且当前线程总数还没有达到线程池的最大线程数，就会创建一个新的线程来执行任务；如果当前线程总数已经达到线程池的最大线程数，那么这个任务就会被放入任务队列，等待有线程空闲时再执行。

线程池的实现方式和具体功能可能会因为不同的编程语言和框架而有所不同，但基本的工作原理和优点是一致的。

在C++中，线程池可以通过使用POSIX线程库或者标准库中的thread和mutex来实现。

C语言版线程池

`Thread.h`

#pragma once
#include <pthread.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>

// 任务结构体
typedef struct Task
{
    void (*function)(void *arg);
    void *arg;
} Task;

// 线程池结构体
typedef struct ThreadPool
{
    Task *taskQ;       // 任务队列
    int queueSize;     // 任务个数
    int queueCapacity; // 容量
    int queueFront;    // 队头->取数据
    int queueRear;     // 队尾->读数据

    pthread_t managerID;       // 管理线程的ID
    pthread_t *threadIDs;      // 线程数组的ID
    int minNum;                // 最小线程个数
    int maxNum;                // 最大线程个数
    int busyNum;               // 忙碌线程个数
    int liveNum;               // 存活线程个数
    int exitNUm;               // 销毁线程个数
    pthread_mutex_t mutexPool; // 锁整个线程池
    pthread_mutex_t mutexBusy; // 锁busyNum变量
    pthread_cond_t notFull;    // 任务队列是否满了
    pthread_cond_t notEmpty;   // 任务队列是否空了

    int shutdown; // 是否要销毁线程池，销毁为1，不销毁为0
} ThreadPool;

// 创建线程池并进行初始化
ThreadPool *threadPoolCreate(int minNum, int maxNum, int queueCapacity);

// 销毁线程池
int threadPoolDestory(ThreadPool *pool);

// 给线程池添加任务
void threadPoolAdd(ThreadPool *pool, void (*func)(void *), void *arg);

// 获取线程池中的工作的线程的个数
int getThreadPoolBusyNum(ThreadPool* pool);

// 获取线程池中的活着的线程的个数
int getThreadPoolLiveNum(ThreadPool* pool);

/

void manager(void *arg);
void worker(void *arg);
void threadExit(ThreadPool *pool);

首先，定义了一个任务结构体（Task），它包含一个函数指针和一个指向函数参数的指针。这个结构体用于表示线程池中的一个任务。
然后，定义了一个线程池结构体（ThreadPool）。这个结构体包含了一个任务队列，队列的大小和容量，队列的头和尾，管理线程的ID，线程数组的ID，最小和最大线程数，忙碌线程数，存活线程数，销毁线程数，两个互斥锁（用于保护线程池和busyNum变量），两个条件变量（用于表示任务队列是否满了和是否空了），以及一个表示是否要销毁线程池的标志。
然后，声明了一些函数，包括创建和销毁线程池，向线程池添加任务，获取线程池中忙碌和存活线程数的函数。
最后，声明了两个函数，分别是管理线程和工作线程的函数，以及一个线程退出的函数。

这个线程池的工作原理是：创建线程池时，会创建一定数量的工作线程和一个管理线程。工作线程会循环地从任务队列中取出任务并执行。管理线程则负责管理线程池，包括根据任务数量动态调整工作线程的数量，以及销毁不再需要的工作线程。

`Thread.c`

#include "ThreadPool.h"

const int NUMBER = 2; // 添加线程个数

ThreadPool *threadPoolCreate(int minNum, int maxNum, int queueCapacity)
{
    ThreadPool *pool = (ThreadPool *)malloc(sizeof(ThreadPool));
    do
    {
        if (NULL == pool)
        {
            printf("pool malloc failed...\n");
            break;
        }

        pool->threadIDs = (pthread_t *)malloc(sizeof(pthread_t) * maxNum);
        if (NULL == pool->threadIDs)
        {
            printf("pool->threadIDs malloc failed...\n");
            break;
        }
        memset(pool->threadIDs, 0, sizeof(pthread_t) * maxNum);
        pool->minNum = minNum;
        pool->maxNum = maxNum;
        pool->busyNum = 0;
        pool->exitNUm = 0;
        pool->liveNum = minNum;

        if (0 != pthread_mutex_init(&pool->mutexPool, NULL) ||
            0 != pthread_mutex_init(&pool->mutexBusy, NULL) ||
            0 != pthread_cond_init(&pool->notEmpty, NULL) ||
            0 != pthread_cond_init(&pool->notFull, NULL))
        {
            printf("mutex or condition failed...\n");
            break;
        }

        pool->taskQ = (Task *)malloc(sizeof(Task) * queueCapacity);
        if (NULL == pool->taskQ)
        {
            printf("pool->taskQ malloc failed...\n");
            pthread_mutex_destroy(&pool->mutexBusy);
            pthread_mutex_destroy(&pool->mutexPool);
            pthread_cond_destroy(&pool->notEmpty);
            pthread_cond_destroy(&pool->notFull);
            break;
        }
        pool->queueCapacity = queueCapacity;
        pool->queueFront = 0;
        pool->queueRear = 0;
        pool->queueSize = 0;

        pool->shutdown = 0;

        pthread_create(&pool->managerID, NULL, manager, pool);
        for (int i = 0; i < minNum; i++)
        {
            pthread_create(&pool->threadIDs[i], NULL, worker, pool);
        }
        return pool;
    } while (0);
    if (pool && pool->taskQ)
        free(pool->taskQ);
    if (pool && pool->threadIDs)
        free(pool->threadIDs);
    if (pool)
        free(pool);
    return NULL;
}

int threadPoolDestory(ThreadPool *pool)
{
    if (NULL == pool)
        return -1;
    // 关闭线程池
    pool->shutdown = 1;
    // 阻塞回收管理者线程
    pthread_join(pool->managerID, NULL);
    // 唤醒阻塞的消费者线程
    for (int i = 0; i < pool->liveNum; ++i)
    {
        pthread_cond_signal(&pool->notEmpty);
    }
    // 释放堆内存
    if (pool->taskQ)
    {
        free(pool->taskQ);
        pool->taskQ = NULL;
    }
    if (pool->threadIDs)
    {
        free(pool->threadIDs);
        pool->threadIDs = NULL;
    }
    printf("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    pthread_mutex_destroy(&pool->mutexPool);
    printf("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    pthread_mutex_destroy(&pool->mutexBusy);
    printf("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    pthread_cond_destroy(&pool->notFull);
    printf("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    pthread_cond_destroy(&pool->notEmpty);
    printf("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    
    free(pool);
    pool = NULL;
    return 0;
}

void threadPoolAdd(ThreadPool *pool, void (*func)(void *), void *arg)
{
    pthread_mutex_lock(&pool->mutexPool);
    while (pool->queueSize == pool->queueCapacity && !pool->shutdown)
    {
        // 阻塞生产者线程
        pthread_cond_wait(&pool->notFull, &pool->mutexPool);
    }
    if (pool->shutdown)
    {
        pthread_mutex_unlock(&pool->mutexPool);
        return;
    }
    // 添加任务
    pool->taskQ[pool->queueRear].function = func;
    pool->taskQ[pool->queueRear].arg = arg;
    pool->queueRear = (pool->queueRear + 1) % pool->queueCapacity;
    pool->queueSize++;

    pthread_cond_signal(&pool->notEmpty);
    pthread_mutex_unlock(&pool->mutexPool);
}

int getThreadPoolBusyNum(ThreadPool *pool)
{
    pthread_mutex_lock(&pool->busyNum);
    int busyNum = pool->busyNum;
    pthread_mutex_unlock(&pool->busyNum);
    return busyNum;
}

int getThreadPoolLiveNum(ThreadPool *pool)
{
    pthread_mutex_lock(&pool->mutexPool);
    int liveNum = pool->liveNum;
    pthread_mutex_unlock(&pool->mutexPool);
    return liveNum;
}

void manager(void *arg)
{
    ThreadPool *pool = (ThreadPool *)arg;
    while (!pool->shutdown)
    {
        // 每三秒检测一次
        sleep(3);

        // 取出线程池中任务的数量和当前线程的数量
        pthread_mutex_lock(&pool->mutexPool);
        int queueSize = pool->queueSize;
        int liveNum = pool->liveNum;
        pthread_mutex_unlock(&pool->mutexPool);

        // 取出忙的线程的数量
        pthread_mutex_lock(&pool->mutexBusy);
        int busyNum = pool->busyNum;
        pthread_mutex_unlock(&pool->mutexBusy);

        // 添加线程
        // 任务个数 > 存活的线程个数 && 存活的线程个数 < 最大线程数
        if (queueSize > liveNum && liveNum < pool->maxNum)
        {
            pthread_mutex_lock(&pool->mutexPool);
            int counter = 0;
            for (int i = 0; i < pool->maxNum && counter < NUMBER && pool->liveNum < pool->maxNum; ++i)
            {
                if (0 == pool->threadIDs[i])
                {
                    pthread_create(&pool->threadIDs[i], NULL, worker, pool);
                    counter++;
                    pool->liveNum++;
                }
            }
            pthread_mutex_unlock(&pool->mutexPool);
        }

        // 销毁线程
        // 忙的线程*2 < 存活的线程数 && 存活的线程数 > 最小的线程数
        if (busyNum * 2 < liveNum && liveNum > pool->minNum)
        {
            pthread_mutex_lock(&pool->mutexPool);
            pool->exitNUm = NUMBER;
            pthread_mutex_unlock(&pool->mutexPool);
            // 让工作的线程自杀
            for (int i = 0; i < NUMBER; i++)
            {
                pthread_cond_signal(&pool->notEmpty);
            }
        }
    }
}

void worker(void *arg)
{
    ThreadPool *pool = (ThreadPool *)arg;
    while (1)
    {
        pthread_mutex_lock(&pool->mutexPool);
        // 判断队列是否为空
        while (0 == pool->queueSize && !pool->shutdown)
        {
            // 阻塞工作线程
            pthread_cond_wait(&pool->notEmpty, &pool->mutexPool);

            // 判断是不是要销毁线程
            if (pool->exitNUm > 0)
            {
                pool->exitNUm--;
                if (pool->liveNum > pool->minNum)
                {
                    pool->liveNum--;
                    pthread_mutex_unlock(&pool->mutexPool);
                    threadExit(pool);
                }
            }
        }

        // 判断线程池是否被关闭了
        if (pool->shutdown)
        {
            pthread_mutex_unlock(&pool->mutexPool);
            threadExit(pool);
        }

        // 从任务队列中取出一个任务
        Task task;
        task.function = pool->taskQ[pool->queueFront].function;
        task.arg = pool->taskQ[pool->queueFront].arg;
        // 移动头节点
        pool->queueFront = (pool->queueFront + 1) % pool->queueCapacity;
        pool->queueSize--;

        // 解锁
        pthread_mutex_unlock(&pool->mutexPool);
        // 消费者消费
        pthread_cond_signal(&pool->notFull);

        printf("thread %ld start working...\n", pthread_self());
        pthread_mutex_lock(&pool->mutexBusy);
        pool->busyNum++;
        pthread_mutex_unlock(&pool->mutexBusy);

        task.function(task.arg);
        free(task.arg);
        task.arg = NULL;

        printf("thread %ld end working...\n", pthread_self());
        pthread_mutex_lock(&pool->mutexBusy);
        pool->busyNum--;
        pthread_mutex_unlock(&pool->mutexBusy);
    }
}

void threadExit(ThreadPool *pool)
{
    pthread_t tid = pthread_self();
    for (int i = 0; i < pool->maxNum; i++)
    {
        if (tid == pool->threadIDs[i])
        {
            pool->threadIDs[i] = 0;
            printf("threadExit() called,%ld exiting...\n", tid);
            break;
        }
    }
    pthread_exit(NULL);
}

threadPoolCreate函数是创建线程池并进行初始化的函数。它首先为线程池结构体分配内存，然后为线程ID数组分配内存，初始化线程池的各个属性，包括最小线程数、最大线程数、忙碌线程数、存活线程数等。然后初始化互斥锁和条件变量，为任务队列分配内存，并初始化任务队列的各个属性。最后创建管理线程和工作线程。
threadPoolDestory函数是销毁线程池的函数。它首先设置线程池的关闭标志，然后回收管理线程，唤醒所有阻塞的工作线程，释放任务队列和线程ID数组的内存，销毁互斥锁和条件变量，最后释放线程池的内存。
threadPoolAdd函数是向线程池添加任务的函数。它首先锁定线程池，然后等待任务队列不满，然后向任务队列中添加任务，并唤醒一个等待任务的工作线程。
getThreadPoolBusyNum和getThreadPoolLiveNum函数分别用于获取线程池中忙碌线程数和存活线程数。
manager函数是管理线程的函数。它在一个循环中不断检查任务队列的大小和线程池的状态，根据需要创建或销毁工作线程。
worker函数是工作线程的函数。它在一个循环中不断从任务队列中取出任务并执行。
threadExit函数是线程退出的函数。它首先获取当前线程的ID，然后在线程ID数组中找到对应的位置并将其设置为0，最后调用pthread_exit函数退出线程。

`main.c`

#include "ThreadPool.h"

void taskFunc(void* arg)
{
    int num = *(int *)arg;
    printf("thread %ld is working,number = %d\n",pthread_self(),num);
    sleep(1);
}

int main()
{
    // 创建线程池
    ThreadPool* pool=threadPoolCreate(3,5,50);
    for(int i=0;i<30;++i)
    {
        int *num=(int *)malloc(sizeof(int));
        *num=i+100;
        threadPoolAdd(pool,taskFunc,num);
    }
    sleep(10);
    threadPoolDestory(pool);
    return 0;
}