thread 线程池

线程池是一种用于管理和复用线程的机制，它可以提高多线程应用程序的性能和效率。在多线程编程中，创建和销毁线程是一项开销较大的操作，而线程池可以通过预先创建一定数量的线程，并将任务分配给这些线程来减少线程的创建和销毁次数。

线程池通常由以下几个组件组成：
1. 任务队列：用于存储待执行的任务。
2. 线程管理器：用于创建、销毁和管理线程。
3. 工作线程：实际执行任务的线程。

当一个任务需要执行时，线程池会从任务队列中取出一个任务，并将其分配给一个空闲的工作线程执行。当任务执行完毕后，工作线程会返回线程池，并等待下一个任务的分配。这样就避免了频繁地创建和销毁线程，提高了线程的复用率和整体性能。

使用线程池可以带来以下好处：
1. 提高性能：通过复用线程，减少了线程的创建和销毁开销，提高了程序的响应速度和吞吐量。
2. 控制并发度：可以限制同时执行的线程数量，避免系统资源被过度占用。
3. 提供任务队列：可以将任务按照一定的策略进行排队，保证任务的有序执行。
4. 提供线程管理和监控：可以方便地管理线程的状态、监控线程的执行情况。

相关问题

c++ thread 线程池

C++中实现线程池的基本思路是创建一个固定大小的线程池（线程数量等于处理器数量），然后将需要执行的任务放入任务队列中，线程池中的线程从任务队列中取出任务进行执行。

以下是一个简单的C++线程池实现代码：

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

using namespace std;

class ThreadPool {
public:
    ThreadPool(size_t num_threads) {
        for (size_t i = 0; i < num_threads; ++i) {
            threads.emplace_back([this]{
                while (true) {
                    function<void()> task;
                    {
                        unique_lock<mutex> lock(m);
                        cv.wait(lock, [this]{
                            return !tasks.empty();
                        });
                        task = move(tasks.front());
                        tasks.pop();
                    }
                    task();
                }
            });
        }
    }

    ~ThreadPool() {
        {
            unique_lock<mutex> lock(m);
            done = true;
        }
        cv.notify_all();
        for (auto& thread : threads) {
            thread.join();
        }
    }

    template<typename F, typename... Args>
    void enqueue(F&& f, Args&&... args) {
        auto task = make_shared<packaged_task<void()>>(bind(forward<F>(f), forward<Args>(args)...));
        {
            unique_lock<mutex> lock(m);
            tasks.push([task]{
                (*task)();
            });
        }
        cv.notify_one();
    }

private:
    vector<thread> threads;
    queue<function<void()>> tasks;
    mutex m;
    condition_variable cv;
    bool done = false;
};

在上面的代码中，使用了一个vector来保存线程池中的所有线程，使用一个队列来保存所有需要执行的任务。enqueue函数用于向任务队列中添加一个新任务。

每个线程都会从任务队列中取出任务进行执行，如果队列为空，则线程会一直等待直到队列中有任务。线程池中的所有线程在析构函数中会被join掉，确保所有任务都被执行完毕。

c++ thread 线程池代码

以下是一个简单的 C++ 线程池实现代码，使用了 C++11 中的 `<thread>` 和 `<queue>` 库：

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

class ThreadPool {
public:
    ThreadPool(size_t numThreads) {
        for (size_t i = 0; i < numThreads; ++i) {
            workers.emplace_back([this] {
                for (;;) {
                    std::function<void()> 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();
                }
            });
        }
    }

    template <typename Function>
    void enqueue(Function&& f) {
        {
            std::unique_lock<std::mutex> lock(queue_mutex);

            tasks.emplace(std::forward<Function>(f));
        }
        condition.notify_one();
    }

    ~ThreadPool() {
        {
            std::unique_lock<std::mutex> lock(queue_mutex);
            stop = true;
        }
        condition.notify_all();
        for (std::thread& worker: workers) {
            worker.join();
        }
    }

private:
    std::vector<std::thread> workers;
    std::queue<std::function<void()>> tasks;

    std::mutex queue_mutex;
    std::condition_variable condition;
    bool stop = false;
};

使用方式：

ThreadPool pool(4); // 创建一个具有 4 个线程的线程池

pool.enqueue([] {
    // 执行任务 1
});

pool.enqueue([] {
    // 执行任务 2
});

// 等待所有任务完成