c++线程池(一)

c++线程池

概要

实现一个简单的线程池。
线程池介绍：
线程池通常由一个线程池管理器、工作队列和一组工作线程组成。线程池可以有效地控制线程的数量，减少线程创建和销毁的开销，并提高系统的性能和稳定性。线程池中的线程都是后台线程，每个线程都使用默认的堆栈大小，以默认的优先级运行，并处于多线程单元中。
线程池的优点
1、降低资源消耗：通过重复利用已创建的线程降低线程创建和销毁造成的消耗。
2、提高响应速度：当任务到达时，任务可以不需要等到线程创建就能立即执行。
3、提高线程的可管理性：线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配、调优和监控。

整体架构流程

线程池代码实现

//<ThreadPool.h>
#include <iostream>
#include <vector>
#include <queue>
#include <thread>
#include <condition_variable>
#include <mutex>
#include <functional>
#include <windows.h>

// 任务类型，这里简单地使用 std::function<void()>
using Task = std::function<void()>;

class ThreadPool {
public:
    ThreadPool(int threadNumbers) :max_threads(threadNumbers), stop(false)
    {
        for (int i = 0; i < threadNumbers; i++)
        {
            workers.emplace_back(WorkerThread, this);
        }
    }
    ~ThreadPool()
    {
        {
            std::unique_lock<std::mutex> lock(queue_mutex);
            stop = true;
        }
        cond_var.notify_all(); // 通知所有工作线程停止
        for (std::thread& worker : workers) {
            worker.join();
        }
    }

    // 添加新任务到线程池
    void AddTask(Task task);
private:
    //线程的工作函数
    static unsigned int WorkerThread(void* arg);

    std::vector<std::thread> workers; // 工作线程池
    std::queue<Task> tasks;           // 任务队列
    std::mutex queue_mutex;           // 用于保护任务队列的互斥锁
    std::condition_variable cond_var; // 条件变量，用于通知工作线程有新任务
    int max_threads;                  // 线程池的最大线程数
    bool stop;                        // 线程池停止标志
};

//<ThreadPool.cpp>
#include "ThreadPool.h"
void  ThreadPool::AddTask(Task task) {
    {
        std::unique_lock<std::mutex> lock(queue_mutex);
        tasks.push(task);
    }
    cond_var.notify_one(); // 通知一个工作线程有新任务
}


unsigned int ThreadPool::WorkerThread(void* arg)
{
    ThreadPool* pool = (ThreadPool*)arg;
    while (true)
    {
        std::unique_lock<std::mutex>lock(pool->queue_mutex);
        pool->cond_var.wait(lock, [pool] { return pool->stop || !pool->tasks.empty(); });
        if (pool->stop && pool->tasks.empty()) {
            break;
        }
        Task task = pool->tasks.front();
        pool->tasks.pop();
        task(); // 执行任务
    }
    return 0;
}

//<main.cpp>
#include"ThreadPool.h"

// 示例任务函数
void DoWork(int id) {
    std::cout << "Task " << id << " is running on thread " << std::this_thread::get_id() << std::endl;
    Sleep(1000); // 模拟耗时任务
}

int main() {
    const int num_tasks = 10;
    const int num_threads = 4;

    ThreadPool pool(num_threads);

    // 添加任务到线程池
    for (int i = 0; i < num_tasks; ++i) {
        pool.AddTask(std::bind(DoWork, i));
    }

    // 等待所有任务完成
    pool.AddTask([]() {
        std::cout << "All tasks are completed." << std::endl;
        });

    return 0;
}

流程实现

一、创建线程类，加入所需的私有成员

    std::vector<std::thread> workers; // 工作线程池
    std::queue<Task> tasks;           // 任务队列
    std::mutex queue_mutex;           // 用于保护任务队列的互斥锁
    std::condition_variable cond_var; // 条件变量，用于通知工作线程有新任务
    int max_threads;                  // 线程池的最大线程数
    bool stop;                        // 线程池停止标志

二、实现构造函数
初始化线程池最大线程数，并将线程工作函数加入到工作线程池中

    ThreadPool(int threadNumbers) :max_threads(threadNumbers), stop(false)
    {
        for (int i = 0; i < threadNumbers; i++)
        {
            workers.emplace_back(WorkerThread, this);
        }
    }

技术细节
①emplace_back
三、工作函数实现
工作函数进入while循环后，通过unique_lock上锁，后调用condition_variable的wait方法，解锁并阻塞线程，等待唤醒，可以通过cond_var.notify_one()进行唤醒，唤醒后，进入判断条件，线程池停止标志为真或者任务队列不为空，继续执行代码，从任务队列中取出第一个任务，并从队列里弹出，然后执行任务。

unsigned int ThreadPool::WorkerThread(void* arg)
{
    ThreadPool* pool = (ThreadPool*)arg;
    while (true)
    {
        std::unique_lock<std::mutex>lock(pool->queue_mutex);
        pool->cond_var.wait(lock, [pool] { return pool->stop || !pool->tasks.empty(); });
        if (pool->stop && pool->tasks.empty()) {
            break;
        }
        Task task = pool->tasks.front();
        pool->tasks.pop();
        task(); // 执行任务
    }
    return 0;
}

②condition_variable
四、添加任务接口实现
将任务添加到任务队列中，并唤醒一个线程去执行。

void  ThreadPool::AddTask(Task task) {
    {
        std::unique_lock<std::mutex> lock(queue_mutex);
        tasks.push(task);
    }
    cond_var.notify_one(); // 通知一个工作线程有新任务
}

五、测试函数

#include"ThreadPool.h"
#include <random>

int random()
{
    std::random_device rd;
    std::mt19937 gen(rd());

    // 创建一个分布，用于定义随机数的范围
    std::uniform_int_distribution<> distr(1000, 2000);

    // 生成随机数
    int random_number = distr(gen);
    return random_number;
}


// 示例任务函数
void DoWork(int id) {
    std::cout << "Task " << id << " is running on thread " << std::this_thread::get_id() << std::endl;
    Sleep(random()); // 模拟耗时任务
}

int main() {
    const int num_tasks = 5;
    const int num_threads = 2;

    ThreadPool pool(num_threads);

    // 添加任务到线程池
    for (int i = 0; i < num_tasks; ++i) {
        pool.AddTask(std::bind(DoWork, i));
    }

    // 等待所有任务完成
    pool.AddTask([]() {
        std::cout << "All tasks are completed." << std::endl;
        });

    return 0;
}

六、结果

技术细节

①emplace_back：workers.emplace_back(WorkerThread, this)
创建了一个新的线程对象，该对象将WorkerThread作为它的任务，并将this指针（即指向ThreadPool对象的指针）作为参数传递给WorkerThread函数
②condition_variable：
c++标准库中的一个类，常用与多线程并发，与互斥锁一起应用，一般有两种用法：
1、wait(): 这个方法会使调用线程阻塞，直到被另一个线程唤醒。通常，这个方法会在一个互斥锁的保护区域内被调用，并且会解锁互斥锁，允许其他线程获取该锁并执行。当条件变量被另一个线程通知（通过 notify_one() 或 notify_all() 方法）时，等待的线程会被唤醒并重新获取互斥锁。
2、notify_one() 和 notify_all(): 这两个方法用于唤醒一个或多个正在等待条件变量的线程。notify_one() 唤醒一个等待的线程（如果有的话），而 notify_all() 唤醒所有等待的线程。

小结

这是一个简单的线程池，后续还会在优化，增加功能。