《ZLToolKit源码学习笔记》（7）线程模块之线程池组件：任务队列与线程组

template<typename T>
class TaskQueue {
public:
    //添加任务
    template<typename C>
    void push_task(C &&task_func);
    template<typename C>
    void push_task_first(C &&task_func);
    //清空任务列队
    void push_exit(size_t n);
    //获取任务
 bool get_task(T &tsk);
    size_t size();
private:
    List<T> _queue;
    mutable mutex _mutex;
    semaphore _sem;
};

1.1、semaphore

封装条件变量condition_variable_any的使用，提供了post和wait接口。

void post(size_t n = 1) {
    unique_lock<mutex> lock(_mutex);
    _count += n;
    if(n == 1){
        _condition.notify_one();
    }else{
        _condition.notify_all();
    }
}

void wait() {
    unique_lock<mutex> lock(_mutex);
    while (_count == 0) {
        _condition.wait(lock);
    }
    --_count;
}

_count成员记录希望wait接口返回的次数。默认情况下，每调用一次post，_count加1，通过notify_one，所有等待在_condition.wait上的线程其中一个被唤醒。如果n大于1，将通过notify_all唤醒所有等待在_condition.wait上的线程。

对于生产者消费者模型，count记录产品数量，post每次生产一个或者多个产品，wait每次消费一个产品，wait被唤醒后，会一直执行，直到产品都被消耗完。

在线程池的实现中，作者通过在没有添加任务的情况下，调用post(n>1)来控制线程的退出。

1.2、TaskQueue接口分析

1.2.1、添加任务至队列

template<typename C>
void push_task(C &&task_func) {
    {
        lock_guard<decltype(_mutex)> lock(_mutex);
        _queue.emplace_back(std::forward<C>(task_func));
    }
    _sem.post();
}

template<typename C>
void push_task_first(C &&task_func) {
    {
        lock_guard<decltype(_mutex)> lock(_mutex);
        _queue.emplace_front(std::forward<C>(task_func));
    }
    _sem.post();
}

push_task在队列的尾部添加任务，push_task_first在队列的头部添加任务。

为什么不直接使用void push_task(T &&task_func)而要用模板呢？

template<typename C> void push_task(C &&task_func);
void push_task(T &&task_func);
void push_task(T &task_func);
void push_task(const T &task_func);

push_task(T &&task_func)只能接受右值引用，push_task(T &task_func)不能接受右值引用，push_task(const T &task_func)接受右值时会产生临时变量。模板因为引用折叠，既能接受左值，也能接受右值。

1.2.2、从队列中获取一个任务

bool get_task(T &tsk) {
    _sem.wait();
    lock_guard<decltype(_mutex)> lock(_mutex);
    if (_queue.size() == 0) {
        return false;
    }
    //改成右值引用后性能提升了1倍多！
    tsk = std::move(_queue.front());
    _queue.pop_front();
    return true;
}

阻塞在条件变量上，等待队列中添加任务或者通过push_exit主动退出。

1.2.3、清空任务列队(让get_task接口返回false)

void push_exit(size_t n) {
    _sem.post(n);
}

任务的数量由semaphore类中的_count成员控制，正常情况下，每给队列添加一个任务，触发一次_sem.post(1)，任务数量加1，每次wait返回时，队列中都是有任务的，get_task总能获取到一个任务，返回true。此处，在实际没有给队列中添加任务的情况下，让wait多返回了n次，这n次get_task肯定是获取不到任务的，会返回false。线程池中利用get_task返回false来达到退出线程的目的。如启动了4个工作线程来获取任务，每个线程都等待在get_task上，主线程中调用push_exit(4)，get_task就会有四次返回false，以此让工作线程退出。

二、线程组thread_group

管理一组线程，接口：添加线程、删除线程、等待线程组中所有线程退出、判断指定的线程是否在线程组中、判断当前线程是否在线程组中。

2.1、判断当前线程是否在线程组中

bool is_this_thread_in() {
    auto thread_id = this_thread::get_id();
    if(_thread_id == thread_id){//意义是？比unordered_map遍历快？为了提高运行效率？
        return true;
    }
    return _threads.find(thread_id) != _threads.end();
}

2.2、判断指定的线程是否在线程组中

bool is_thread_in(thread* thrd) {
    if (!thrd) {
        return false;
    }
    auto it = _threads.find(thrd->get_id());
    return it != _threads.end();
}

2.3、添加线程

template<typename F>
thread* create_thread(F &&threadfunc) {
    auto thread_new = std::make_shared<thread>(threadfunc);
    _thread_id = thread_new->get_id();
    _threads[_thread_id] = thread_new;
    return thread_new.get();
}

2.4、删除线程

void remove_thread(thread* thrd) {
    auto it = _threads.find(thrd->get_id());
    if (it != _threads.end()) {
        _threads.erase(it);
    }
}

2.5、等待线程组中所有线程退出

void join_all() {
    if (is_this_thread_in()) {
        throw runtime_error("thread_group: trying joining itself");
    }
    for (auto &it : _threads) {
        if (it.second->joinable()) {
            it.second->join(); //等待线程主动退出
        }
    }
    _threads.clear();
}