基于C++11的100行实现简单线程池

基于C++11的100行实现简单线程池

1 线程池原理

线程池是一种多线程处理形式，处理过程中将任务添加到队列，然后在创建线程后自动启动这些任务。线程池线程都是后台线程。每个线程都使用默认的堆栈大小，以默认的优先级运行，并处于多线程单元中。

线程池组成部分：

线程池管理器:用于创建并管理线程池

工作线程: 线程池中实际执行的线程

任务接口: 尽管线程池大多数情况下是用来支持网络服务器，但是我们将线程执行的任务抽象出来，形成任务接口，从而是的线程池与具体的任务无关。

任务队列:线程池的概念具体到实现则可能是队列，链表之类的数据结构，其中保存执行线程。

2 并发下线程池的最佳数量

如果是CPU密集型应用，则线程池大小设置为N+1；（对于计算密集型的任务，在拥有N个处理器的系统上，当线程池的大小为N+1时，通常能实现最优的效率。(即使当计算密集型的线程偶尔由于缺失故障或者其他原因而暂停时，这个额外的线程也能确保CPU的时钟周期不会被浪费。摘自《Java Concurrency In Practise》)。因为CPU密集型任务使得CPU使用率很高，若开过多的线程数，只能增加上下文切换的次数，因此会带来额外的开销。I
如果是IO密集型应用，则线程池大小设置为2N+1；IO密集型任务可以使用稍大的线程池，一般为2*CPU核心数。IO密集型任务CPU使用率并不高，因此可以让CPU在等待IO的时候去处理别的任务，充分利用CPU时间。

2.1 线程池是否一定比单线程高效？

答案是否定的，比如Redis就是单线程的，但它却非常高效，基本操作都能达到十万量级/s。从线程这个角度来看，部分原因在于：多线程带来线程上下文切换开销，单线程就没有这种开销 锁

当然“Redis很快”更本质的原因在于： 
Redis基本都是内存操作，这种情况下单线程可以很高效地利用CPU。而多线程适用场景一般是：存在相当比例的IO和网络操作。

3 线程池设计的C++11的特性

• std::vector
• std::thread
• std::mutex
• std::future
• std::condition_variable

C++代码：

threadpool.h

#pragma once
#include <iostream>
#include <vector>
#include <queue>
#include <mutex>
#include <condition_variable>
#include <stdexcept>

const int MAX_THREADS = ; // 线程池阈值

template <typename T>
class threadpool
{
public:
    threadpool(int number = ); // 线程池构造函数，传入线程数，默认为1
    ~threadpool();                // 线程池析构函数
    bool append(T* request);    // 添加任务到任务队列

private:
    static void* worker(void* arg); // 工作线程数组
    void run();                        // 工作线程的执行函数

private:
    std::vector<std::thread> work_threads;  // 工作线程
    std::queue<T*> task_queues;                // 任务队列
    std::mutex queue_mutex;                    // 队列互斥锁
    std::condition_variable condition;        // 条件变量
    bool stop;                                // 停止标志
};

template <typename T>
threadpool<T>::threadpool(int number) :stop(false)
{
    if (number <=  || number > MAX_THREADS) // 如果number小于等于0或者大于线程池阈值，抛出异常
        throw std::exception();

    for (int i = ; i < number; i++)
    {
        std::cout << "创建第" << i << "个线程" << std::endl;
        // 添加worker函数到线程中
        work_threads.emplace_back(worker, this); // Q:this是什么作用，为什么没了this会出错？
    }
}

template <typename T>
inline threadpool<T>::~threadpool()
{
    {
        std::unique_lock<std::mutex> lock(queue_mutex); // 拿锁
        stop = true;                                    // 停止标志置位true
    }
    condition.notify_all();                                // 通知所有工作线程，唤醒后因为stop为true了，所有都会结束
    for (auto& ww : work_threads)
        ww.join();
}

template <typename T>
bool threadpool<T>::append(T* request) // 添加一个新的工作任务到任务队列
{
    {
        std::unique_lock<std::mutex> lock(queue_mutex);
        task_queues.emplace(request);  // 将任务添加到任务队列
    }
    condition.notify_one();               // 发送通知，唤醒某一个工作线程执行任务
    return true;
}

template <typename T>
void* threadpool<T>::worker(void* arg)
{
    threadpool* pool = (threadpool*)arg;
    pool->run();
    return pool;
}

template <typename T>
void threadpool<T>::run()
{
    while (!stop)
    {
        std::unique_lock<std::mutex> lk(queue_mutex);                            // 拿锁（独占所有权式）
        this->condition.wait(lk, [this] {return !this->task_queues.empty(); }); // 等待条件成立
        /*
            执行条件变量等待的时候，已经拿到了锁(即lock已经拿到锁，没有阻塞)
            这里将会unlock释放锁，其他线程可以继续拿锁，但此处仍然阻塞，等待条件成立
            一旦收到其他线程notify_*唤醒，则再次lock，然后进行条件判断
            当{return !this->task_queues.empty(); }的结果为false将阻塞
            条件为true时候解除阻塞。此时lock依然为锁住状态
        */
        if (this->task_queues.empty())            // 如果任务队列为空，继续
            continue;
        else
        {
            T* request = task_queues.front();   // 取得任务队列首任务
            task_queues.pop();                    // 从队列中移除
            if (request)
                request->process();                // 执行任务
        }
    }
}

main.cpp

#include <iostream>
#include "threadpool.h"

class Task
{
public:
    void process()
    {
        static int a = ;
        ++a;
        std::cout << "run......" << a << std::endl;
    }
};

int main()
{
    threadpool<Task> tp();

    while ()
    {
        std::this_thread::sleep_for(std::chrono::milliseconds());

        Task* t = new Task();
        tp.append(t);
        delete t;
    }
}

参考：

https://blog.csdn.net/gcola007/article/details/78750220

https://blog.csdn.net/qq_34417408/article/details/78895573