70行优雅实现线程池 模拟生产者消费者问题

这段代码摘自，非常的优雅，用了c++新特性tinywebserverhttps://github.com/markparticle/WebServer.git

上代码

/*
 * @Author       : mark
 * @Date         : 2020-06-15
 * @copyleft Apache 2.0
 */ 

#ifndef THREADPOOL_H
#define THREADPOOL_H

#include <mutex>
#include <condition_variable>
#include <queue>
#include <thread>
#include <functional>
#include <cassert>
class ThreadPool {
public:
    explicit ThreadPool(size_t threadCount = 8): pool_(std::make_shared<Pool>()) {
            assert(threadCount > 0);
            for(size_t i = 0; i < threadCount; i++) {
                std::thread([pool = pool_] {
                    std::unique_lock<std::mutex> locker(pool->mtx); //加锁
                    while(true) {
                        if(!pool->tasks.empty()) {
                            auto task = std::move(pool->tasks.front());
                            pool->tasks.pop();
                            locker.unlock();
                            task();
                            locker.lock();
                        } 
                        else if(pool->isClosed) break; //这里break，不需要再unlock了，unqiue_lock会自动释放
                        else pool->cond.wait(locker);
                    }
                }).detach();
            }
    }

    ThreadPool() = default;

    ThreadPool(ThreadPool&&) = default;
    
    ~ThreadPool() {
        if(static_cast<bool>(pool_)) {
            {
                std::lock_guard<std::mutex> locker(pool_->mtx);
                pool_->isClosed = true;
            }
            pool_->cond.notify_all();
        }
    }

    template<class F>
    void AddTask(F&& task) {
        //这里是右值引用，用forward完美转发
        {
            //相当于加锁
            std::lock_guard<std::mutex> locker(pool_->mtx);
            pool_->tasks.emplace(std::forward<F>(task));
            //关闭锁
        }
        //通知一个等待中的线程来处理
        pool_->cond.notify_one();
    }

private:
    struct Pool {
        std::mutex mtx;
        std::condition_variable cond;
        bool isClosed;
        std::queue<std::function<void()>> tasks;
    };
    std::shared_ptr<Pool> pool_;
};


#endif //THREADPOOL_H

lock_guard

std::lock_guard<std::mutex> locker(pool_->mtx);  这一行，介绍的这个模板类，lock_guard

1. 这一个代码块内，都是进行原子操作
2. 当有break return 这种操作时，会自动释放锁
3. 当在这个模块有wait信号量的时候，也会释放锁，获取到了信号量之后，会重新获得锁

注意这个第三点，后面会用到。

explicit

声明类的单参数构造函数，以阻止编译器执行隐式类型转换。啥意思呢，看例子

class MyExplicitClass {
public:
    explicit MyExplicitClass(int value) {
        // 构造函数
    }
};

void processObject(const MyExplicitClass& obj) {
    // 处理 MyExplicitClass 对象的函数
}

int main() {
    MyExplicitClass obj1 = 5;  // 这里会导致编译错误，因为构造函数被声明为 explicit
    MyExplicitClass obj2(5);  // 这种使用方式是合法的

    processObject(5); // 如果构造函数没有使用 explicit 关键字，这里会隐式地构造一个 MyExplicitClass 对象
    processObject(MyExplicitClass(5));  // 这种使用方式是合法的
}

 这里使用了emplicit，就只能通过显式MyExplicit(int )这样，其他的拷贝构造阿，等号都不行。

thread().detach()

thread这个函数有两个参数，一个是需要执行的函数，其他的就是执行函数需要传入的参数，好像要传引用来着，不然改的是实参

detach，这个方法调用之后，把操控权给操作系统了，不需要你调用join，这里需要注意，主进程一定要加一个while(true)的死循环，不然主线程自己退出，整个程序都退出了（子线程被操作系统杀死了）

匿名函数

就是上文thread的第一个参数，[]{} []里的是参数，{}里的是需要执行的代码，注意这里pool传递的是智能指针，可以直接修改外面的值

forward完美转发

forward是用来解决函数参数传递的时候，当把一个函数作为右值引用传递进取，如果原来是右值，他就变成左值了，看例子

#include <iostream>
#include <utility>

void processValue(int& value) {
    std::cout << "Lvalue processed: " << value << std::endl;
}

void processValue(int&& value) {
    std::cout << "Rvalue processed: " << value << std::endl;
}
template<typename T>
void forwardValue(T&& value) {
    processValue(value);
    processValue(std::forward<T>(value));
    processValue(std::move(value));
}


int main() {

    forwardValue(10);
    // 输出
// Lvalue processed: 10
// Rvalue processed: 10
// Rvalue processed: 10
    int x=20;
    std::cout<<"\n";
    forwardValue(x);
    // 输出
// Lvalue processed: 20
// Lvalue processed: 20
// Rvalue processed: 20


    return 0;
}

注意看，这里传入10,forward会保持他为右值，传入x，forward保证他为左值

代码讲解

    struct Pool {
        std::mutex mtx;
        std::condition_variable cond;
        bool isClosed;
        std::queue<std::function<void()>> tasks;
    };

    explicit ThreadPool(size_t threadCount = 8): pool_(std::make_shared<Pool>()) {
            assert(threadCount > 0);
            for(size_t i = 0; i < threadCount; i++) {
                std::thread([pool = pool_] {
                    std::unique_lock<std::mutex> locker(pool->mtx); //加锁
                    while(true) {
                        if(!pool->tasks.empty()) {
                            auto task = std::move(pool->tasks.front());
                            pool->tasks.pop();
                            locker.unlock();
                            task();
                            locker.lock();
                        } 
                        else if(pool->isClosed) break; //这里break，不需要再unlock了，unqiue_lock会自动释放
                        else pool->cond.wait(locker);
                    }
                }).detach();
            }
    }

这个mtx是保护queue的锁，保证同时只有一个线程对他操作。

这个cond是信号量，告知线程有没有新的人物来，没有就等着

这个isColsed用于控制线程池的关闭，析沟的时候，把这个置为true，所有线程都退出

流程： 初始化  创建线程  线程获取mtx锁  判断有任务吗 没有任务--> 等待信号量con

                                                                                           有人物  --> 执行任务，上锁，再获取mtx

任务来了 -- > queue增加一项 --> 通过信号量con告知一个等待的进程

    template<class F>
    void AddTask(F&& task) {
        //这里是右值引用，用forward完美转发
        {
            //相当于加锁
            std::lock_guard<std::mutex> locker(pool_->mtx);
            pool_->tasks.emplace(std::forward<F>(task));
            //关闭锁
        }
        //通知一个等待中的线程来处理
        pool_->cond.notify_one();
    }

这是加任务的函数。

    ~ThreadPool() {
        if(static_cast<bool>(pool_)) {
            {
                std::lock_guard<std::mutex> locker(pool_->mtx);
                pool_->isClosed = true;
            }
            pool_->cond.notify_all();
        }
    }

这是析构函数，std::shared_ptr<Pool> pool_其实等效于pool_.get() != nullptr 判断线程池是否被销毁。

生产者消费者

好了，一个七十多行的代码，知识还挺多。

我们看看应用

#include "threadpool.h"
#include <iostream>
#include <mutex>
#include <thread>
#include <queue>
#include <condition_variable>
#include<cstdlib>
using namespace std;   

#define MAX_QUEUE_SIZE 3

std::mutex mtx;
condition_variable cv_producers,cv_consumers;
queue<int> que;

void consumer(){
    while(true){
        unique_lock<mutex> lck(mtx);
        cv_consumers.wait(lck,[]{return que.size() > 0;});
        //int data=que.front();
        cout<<")";
        que.pop();
        cv_producers.notify_all();
        //this_thread::sleep_for(chrono::milliseconds(5));
    }
}

void producer(){
    while(true){
        unique_lock<mutex> lck(mtx);
        cv_producers.wait(lck,[]{return que.size() < MAX_QUEUE_SIZE;});
        int data=rand()%100;
        cout<<"(";
        que.push(data);
        cv_consumers.notify_all();
        //this_thread::sleep_for(chrono::milliseconds(10));
    }
}

int main() {
    setbuf(stdout, NULL);
    ThreadPool pool(10);
    for(int i=0;i<5;i++){
        pool.AddTask(producer);
        pool.AddTask(consumer);
    }
    while(true){

    }
    return 0;
}

这里是模拟的生产者消费者模型，注意到这里的函数是死循环，所以pool里的是5个生产者，5个消费者，临界区的大小是3，这里我把生产者生产出来的输出一个( 消费者消费输出一个)便于看结果

一眼看过去，最多只有 (((输出，保证括号匹配就可以。