C++线程池库如何处理线程间的同步

在C++中，线程池库通常使用互斥锁（mutex）和条件变量（condition variable）来处理线程间的同步。这些同步原语可以确保线程安全地访问共享数据，并在必要时暂停或唤醒线程。

以下是一个简单的线程池示例，展示了如何使用C++11的互斥锁和条件变量来处理线程间的同步：

#include<
    iostream>
    
#include<
    vector>
    
#include<
    queue>
    
#include<
    thread>
    
#include <
    mutex>
    
#include<
    condition_variable>


class ThreadPool {

public:
    ThreadPool(size_t num_threads) {
    
        for (size_t i = 0;
     i <
     num_threads;
 ++i) {

            workers.emplace_back([this]() {

                while (true) {
    
                    std::function<
    void()>
     task;

                    {
    
                        std::unique_lock<
    std::mutex>
     lock(queue_mutex);

                        condition.wait(lock, [this]() {
     return !tasks.empty() || stop;
 }
    );
    
                        if (stop &
    &
 tasks.empty()) {
    
                            return;

                        }
    
                        task = std::move(tasks.front());
    
                        tasks.pop();

                    }
    
                    task();

                }

            }
    );

        }

    }


    ~ThreadPool() {

        {
    
            std::unique_lock<
    std::mutex>
     lock(queue_mutex);
    
            stop = true;

        }
    
        condition.notify_all();
    
        for (auto&
 worker : workers) {
    
            worker.join();

        }

    }
    

    template<
    typename F, typename... Args>
    
    void enqueue(F&
    &
     f, Args&
    &
... args) {
    
        auto task = std::make_shared<
    std::packaged_task<
    void()>
    >
    (
            std::bind(std::forward<
    F>
    (f), std::forward<
    Args>
    (args)...));

        {
    
            std::unique_lock<
    std::mutex>
     lock(queue_mutex);

            tasks.push([task]() {
     (*task)();
 }
    );

        }
    
        condition.notify_one();

    }
    

private:
    std::vector<
    std::thread>
     workers;
    
    std::queue<
    std::function<
    void()>
    >
     tasks;
    
    std::mutex queue_mutex;
    
    std::condition_variable condition;
    
    bool stop = false;

}
    ;


int main() {
    
    ThreadPool pool(4);
    

    for (int i = 0;
     i <
     8;
 ++i) {

        pool.enqueue([i]() {
    
            std::cout <
    <
     "Task " <
    <
     i <
    <
     " executed by thread "<
    <
     std::this_thread::get_id()<
    <
     std::endl;

        }
    );

    }
    

    return 0;

}
    

在这个示例中，我们创建了一个名为ThreadPool的类，它包含一个工作线程向量、一个任务队列、一个互斥锁和一个条件变量。当线程池被销毁时，所有工作线程将被停止并加入。

enqueue函数模板用于将任务添加到任务队列中。每个工作线程在一个无限循环中等待任务队列中的任务。当条件变量被通知时，线程将检查任务队列是否非空。如果队列非空，线程将获取任务并执行它。如果线程池被停止且任务队列为空，工作线程将退出循环并结束执行。

声明：本文内容由网友自发贡献，本站不承担相应法律责任。对本内容有异议或投诉，请联系2913721942#qq.com核实处理，我们将尽快回复您，谢谢合作！