C/C++教程

简单C++线程池

本文主要是介绍简单C++线程池,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

简单C++线程池

Java 中有一个很方便的 ThreadPoolExecutor,可以用做线程池。想找一下 C++ 的类似设施,尤其是能方便理解底层原理可上手的。网上找到的 demo,基本都是介绍的 projschj 的C++11线程池。这份源码最后的commit日期是2014年,现在是2021年了,本文将在阅读源码的基础上,对这份代码进行一些改造。关于线程池,目前网上讲解最好的一篇文章是这篇 Java线程池实现原理及其在美团业务中的实践,值得一读。

改造后的源码在 https://gitee.com/zhcpku/ThreadPool 进行提供。

projschj 的代码

1. 数据结构

主要包含两个部分,一组执行线程、一个任务队列。执行线程空闲时,总是从任务队列中取出任务执行。具体执行逻辑后面会进行解释。

class ThreadPool {
    // ...
private:
    using task_type = std::function<void()>;
    // need to keep track of threads so we can join them
    std::vector<std::thread> workers;
    // the task queue
    std::queue<task_type> tasks;
};

2. 同步机制

这里包括一把锁、一个条件变量,还有一个bool变量:

  • 锁用于保护任务队列、条件变量、bool变量的访问;
  • 条件变量用于唤醒线程,通知任务到来、或者线程池停用;
  • bool变量用于停用线程池;
class ThreadPool {
    // ...
private:
    // synchronization
    std::mutex queue_mutex;
    std::condition_variable condition;
    bool stop;
};

3. 线程池启动

启动线程池,首先要做的是构造指定数量的线程出来,然后让每个线程开始运行。
对于每个线程,运行逻辑是一样的:尝试从任务队列中获取任务并执行,如果拿不到任务、并且线程池没有被停用,则睡眠等待。
这里线程等待任务使用的是条件变量,而不是信号量或者自旋锁等其他设施,是为了让线程睡眠,避免CPU空转浪费。

// the constructor just launches some amount of workers
inline ThreadPool::ThreadPool(size_t thread_num)
    : stop(false)
{
    for (size_t i = 0; i < thread_num; ++i) {
        workers.emplace_back([this] {
            for (;;) {
                task_type task;
                {
                    std::unique_lock<std::mutex> lock(this->queue_mutex);
                    this->condition.wait(
                        lock, [this] { return this->stop || !this->tasks.empty(); });
                    if (this->stop && this->tasks.empty()) {
                        return;
                    }
                    task = std::move(this->tasks.front());
                    this->tasks.pop();
                }
                task();
            }
        });
    }
}

4.停用线程池

线程的停用,需要让每一个线程停下来,并且等到每个线程都停止再退出主线程才是比较安全的操作。
停止分三步:设置停止标识、通知到每一个线程(睡眠的线程需要唤醒)、等到每一个线程停止。

// the destructor joins all threads
inline ThreadPool::~ThreadPool()
{
    {
        std::unique_lock<std::mutex> lock(queue_mutex);
        stop = true;
    }
    condition.notify_all();
    for (std::thread& worker : workers) {
        worker.join();
    }
}

5. 提交新任务

这是整个线程池的核心,也是写的最复杂,用C++新特性最多的地方,包括但不限于:
自动类型推导、变长模板函数、右值引用、完美转发、原地构造、智能指针、future、bind ……
顺带提一句,要是早有变长模板参数,std::min / std::max 也不至于只能比较两个数大小,再多就得用大括号包起来作为 initialize_list 传进去了。

这里提交任务时,由于我们的任务类型定义为一个无参无返回值的函数对象,所以需要先通过 std::bind 把函数及其参数打包成一个 对应类型的可调用对象,返回值将通过 future 异步获取。然后是要把这个任务插入任务队列末尾,因为任务队列被多线程并发访问,所以需要加锁。
另外需要处理的两个情况,一个是线程睡眠时,新入队任务需要主要唤醒线程;另一个是线程池要停用时,入队操作是非法的。

// add new work item to the pool
template <class F, class... Args>
auto ThreadPool::enqueue(F&& f, Args&&... args)
    -> std::future<typename std::result_of<F(Args...)>::type>
{
    using return_type = typename std::result_of<F(Args...)>::type;

    auto task = std::make_shared<std::packaged_task<return_type()>>(
        std::bind(std::forward<F>(f), std::forward<Args>(args)...));

    std::future<return_type> res = task->get_future();
    {
        std::unique_lock<std::mutex> lock(queue_mutex);

        // don't allow enqueueing after stopping the pool
        if (stop) {
            throw std::runtime_error("enqueue on stopped ThreadPool");
        }
        tasks.emplace([task]() { (*task)(); });
    }
    condition.notify_one();
    return res;
}

改造

以上代码已经足以阐释线程池基本原理了,以下改进主要从可靠性、易用性、使用场景等方面进行改进。

1. non-copyable

线程池本身应该是不可复制的,这里我们通过删除拷贝构造函数和赋值操作符,以及其对用的右值引用版本来实现:

class ThreadPool {
  // ...
private:
    // non-copyable
    ThreadPool(const ThreadPool&) = delete;
    ThreadPool(ThreadPool&&) = delete;
    ThreadPool& operator=(const ThreadPool&) = delete;
    ThreadPool& operator=(ThreadPool&&) = delete;
};

2. default-thread-number

除了手动指定线程个数,更合适的做法是主动探测CPU支持的物理线程数,并以此作为执行线程个数:

class ThreadPool {
public:
    explicit ThreadPool(size_t thread_num = std::thread::hardware_concurrency());
    size_t ThreadCount() { return workers.size(); }
    // ...
};

3. 延迟创建线程

线程不必一次就创建出来,可以等到任务到来的时候再创建,降低资源占用。
// TBD

4. 临时线程数量扩充

线程池的应用场景主要针对的是CPU密集型应用,但是遇到IO密集型场景,也要保证可用性。如果我们的线程个数固定的话,会出现一些问题,比如:

  • 几个IO任务占据了线程,并且进入了睡眠,这个时候CPU空闲,但是后面的任务却得不到处理,任务队列越来越长;
  • 几个线程在睡眠等待某个信号或者资源,但是这个信号或资源的提供者是任务队列中的某个任务,没有空闲线程,提供者永远提供此信号或资源。
    因此我们需要一种机制,临时扩充线程数量,从线程池中的睡眠线程手中“抢回”CPU。
    其实,更好的解决办法是改造线程池,使用固定个数的线程,然后把任务打包到协程中执行,当遇到IO的时候协程主动让出CPU,这样其他任务就能上CPU运行了。毕竟,多线程擅长处理的是CPU密集型任务,多协程才是处理IO密集型任务的。…… 这不就是协程库了嘛!比如 libco、libgo 就是这种解决方案。
    // TBD

5. 线程池停用启动

上面的线程池,其启动停止时机分别是构造和析构的时候,还是太粗糙了。我们为其提供手动启动、停止的函数,并支持停止之后重新启动:
// TBD


总结

不干了,2021年了,研究协程库去了!

参考文献

  1. projschj 的C++11 线程池
  2. Java线程池实现原理及其在美团业务中的实践
这篇关于简单C++线程池的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!