『多线程』线程池(C语言版)

CMakeLists.txt

cmake_minimum_required(VERSION 3.10)
project(main)

include_directories(./)
add_executable(main main.cpp threadpool.cpp)
target_link_libraries(main
    pthread
)

main.cpp

#include <iostream>
#include <unistd.h>
#include "threadpool.h"
using namespace std;

void taskFunc(void *arg)
{
    int *num = (int *)arg;
    cout << "thread is working, number  = " << *num << ", tid = " << pthread_self() << endl; 
    usleep(500000);
}
int main(int argc, const char **argv)
{

    
    ThreadPool *pool = threadPoolCreate(3, 10, 100);
    for (size_t i = 0; i < 100; i++)
    {
        /* code */
        int *num = (int *)malloc(sizeof(int));
        *num = i + 100;
        threadPoolAdd(pool, taskFunc, num);
    }
    sleep(30);
    threadPoolDestory(pool);
    return 0;
}

threadpool.h

#ifndef _THREADPOOL_H
#define _THREADPOOL_H


typedef struct ThreadPool ThreadPool;
//创建线程池并初始化
ThreadPool* threadPoolCreate(int min, int max, int queueCapacity);


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

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

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

//获取线程池中活着的线程的个数

int threadPoolAliveNum(ThreadPool *pool);
//
void* manager(void *arg);
void* worker(void *arg);
void threadExit(ThreadPool *pool);
#endif

threadpool.cpp

#include "threadpool.h"
#include <iostream>
#include <pthread.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
using namespace std;

const int NUMBER = 2;
typedef struct Task
{
    void (*func)(void *arg);
    void *arg;
};

struct ThreadPool
{
    // 任务队列
    Task *taskQ;
    int queueCapacity; // 容量
    int queueSize;     // 当前队列个数
    int queueFront;    // 队头->取数据
    int queueRear;     // 队尾->放数据
    //
    pthread_t managerID;
    pthread_t *threadIDs;
    int minNum;
    int maxNum;
    int busyNum;
    int liveNum;
    int exitNum;

    pthread_mutex_t mutexPool;
    pthread_mutex_t mutexBusy;
    pthread_cond_t notFull;
    pthread_cond_t notEmpty;

    int shutdown;
};

ThreadPool *threadPoolCreate(int min, int max, int queueCapacity)
{
    ThreadPool *pool = (ThreadPool *)malloc(sizeof(ThreadPool));
    do
    {
        if (pool == nullptr)
        {
            cout << "malloc threadpool fial!!!" << endl;
            break;
        }

        pool->threadIDs = (pthread_t *)malloc(sizeof(pthread_t) * max);
        if (pool->threadIDs == nullptr)
        {
            cout << "malloc threadIDs fail!!!" << endl;
            break;
        }
        memset(pool->threadIDs, 0, sizeof(pthread_t) * max);

        pool->minNum = min;
        pool->maxNum = max;
        pool->busyNum = 0;   // 一开始没有busy 线程
        pool->liveNum = min; // 一开始按照最小的线程数初始化线程个数
        pool->exitNum = 0;

        if (pthread_mutex_init(&pool->mutexPool, nullptr) != 0 ||
            pthread_mutex_init(&pool->mutexBusy, nullptr) != 0 ||
            pthread_cond_init(&pool->notFull, nullptr) != 0 ||
            pthread_cond_init(&pool->notEmpty, nullptr) != 0)
        {
            cout << "mutex or condition init fail!!!" << endl;
        }
        // 任务队列
        pool->taskQ = (Task *)malloc(sizeof(Task) * queueCapacity);
        pool->queueCapacity = queueCapacity;
        pool->queueSize = 0;
        pool->queueFront = 0;
        pool->queueRear = 0;

        pool->shutdown = 0;

        // 创建线程

        pthread_create(&pool->managerID, nullptr, manager, pool);
        for (size_t i = 0; i < min; i++)
        {
            pthread_create(&pool->threadIDs[i], nullptr, worker, pool);
        }
        return pool;
    } while (0);

    // 释放资源
    if (pool && pool->threadIDs)
        free(pool->threadIDs);
    if (pool && pool->taskQ)
        free(pool->taskQ);
    if (pool)
        free(pool);

    return nullptr;
}

void *manager(void *arg)
{
    ThreadPool *pool = (ThreadPool *)arg;
    while (!pool->shutdown)
    {
        /* code */
        // 每隔3s检测一次
        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)
        {
            /* code */
            pthread_mutex_lock(&pool->mutexPool);
            int counter = 0;
            for (size_t i = 0;
                 i < pool->maxNum && counter < NUMBER && pool->liveNum < pool->maxNum;
                 ++i)
            {
                /* code */
                if (pool->threadIDs[i] == 0)
                {
                    pthread_create(&pool->threadIDs[i], nullptr, worker, pool);
                    counter++;
                    pool->liveNum++;
                }
            }
            pthread_mutex_unlock(&pool->mutexPool);
        }

        // 销毁线程
        // busy的线程＊2 < 存活的线程 ＆＆ 存活的线程 > 最小线程数
        if (busyNum * 2 < liveNum && liveNum > pool->minNum)
        {
            pthread_mutex_lock(&pool->mutexPool);
            pool->exitNum = NUMBER;
            pthread_mutex_unlock(&pool->mutexPool);
            // 让工作线程自杀
            for (size_t 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);
        if (pool->queueSize == 0 && !pool->shutdown)
        {
            // 阻塞工作线程
            pthread_cond_wait(&pool->notEmpty, &pool->mutexPool);
            // 被manager线程唤醒之后，判断是否需要销毁线程
            if (pool->exitNum > 0)
            {
                pool->exitNum--;
                if (pool->liveNum > pool->minNum)
                {
                    pool->liveNum--;
                    pthread_mutex_unlock(&pool->mutexPool);
                    // pthread_exit(nullptr);
                    threadExit(pool);
                }
            }
        }
        // 判断线程池是否关闭了
        if (pool->shutdown)
        {
            /* code */
            pthread_mutex_unlock(&pool->mutexPool);
            // pthread_exit(nullptr);
            threadExit(pool);
        }

        // 从任务队列中取出一个任务
        Task task;
        task.func = pool->taskQ[pool->queueFront].func;
        task.arg = pool->taskQ[pool->queueFront].arg;

        // 移动头结点
        pool->queueFront = (pool->queueFront + 1) % pool->queueCapacity;
        pool->queueSize--;
        // 解锁
        pthread_cond_signal(&pool->notFull); // 唤醒生产者

        pthread_mutex_unlock(&pool->mutexPool);

        cout << "thread " << pthread_self() << " start working." << endl;
        pthread_mutex_lock(&pool->mutexBusy);
        pool->busyNum++;
        pthread_mutex_unlock(&pool->mutexBusy);
        task.func(task.arg); // 调用函数
        // (*task.func)(task.arg);  //这样调用也可以
        free(task.arg);
        task.arg = nullptr;

        cout << "thread " << pthread_self() << " finish workthreadExiting." << endl;
        pthread_mutex_lock(&pool->mutexBusy);
        pool->busyNum--;
        pthread_mutex_unlock(&pool->mutexBusy);
    }

    return nullptr;
}

void threadExit(ThreadPool *pool)
{
    pthread_t tid = pthread_self();

    for (size_t i = 0; i < pool->maxNum; i++)
    {
        if (pool->threadIDs[i] == tid)
        {
            pool->threadIDs[i] = 0;
            cout << "threadExit() called, " << tid << " exiting..." << endl;
            break;
        }
    }
    pthread_exit(nullptr);
}

void threadPoolAdd(ThreadPool *pool, void (*func)(void *), void *arg)
{
    pthread_mutex_lock(&pool->mutexPool);
    while (pool->queueSize == pool->queueCapacity && !pool->shutdown)
    {
        /* code */
        // 阻塞生产者线程
        pthread_cond_wait(&pool->notFull, &pool->mutexPool);
    }

    if (pool->shutdown)
    {
        /* code */
        pthread_mutex_unlock(&pool->mutexPool);
        return;
    }

    // 添加任务
    pool->taskQ[pool->queueRear].func = 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 threadPoolBusyNum(ThreadPool *pool)
{
    pthread_mutex_lock(&pool->mutexBusy);
    int busyNum = pool->busyNum;
    pthread_mutex_unlock(&pool->mutexBusy);
    return busyNum;
}

int threadPoolAliveNum(ThreadPool *pool)
{
    pthread_mutex_lock(&pool->mutexPool);
    int aliveNum = pool->liveNum;
    pthread_mutex_unlock(&pool->mutexPool);
    return aliveNum;
}
int threadPoolDestory(ThreadPool *pool)
{
    if (pool == nullptr)
    {
        /* code */
        return -1;
    }

    // 关闭线程池
    pool->shutdown = 1;
    // 阻塞回收管理者线程
    pthread_join(pool->managerID, nullptr);
    // 唤醒阻塞的消费者线程
    for (size_t i = 0; i < pool->liveNum; i++)
    {
        /* code */
        pthread_cond_signal(&pool->notEmpty);
    }
    // 释放堆内存
    if (pool->taskQ)
    {
        /* code */
        free(pool->taskQ);
        // pool->taskQ = nullptr;
    }
    if (pool->threadIDs)
    {
        /* code */
        free(pool->threadIDs);
        // pool->threadIDs = nullptr;
    }
    pthread_mutex_destroy(&pool->mutexPool);
    pthread_mutex_destroy(&pool->mutexBusy);
    pthread_cond_destroy(&pool->notFull);
    pthread_cond_destroy(&pool->notEmpty);
    free(pool);
    pool = nullptr;

    return 0;
}