线程池 c++

线程池是一种常见的多线程编程技术，用于管理和调度一组线程以执行多个任务。C++中有许多线程池库可供使用，其中一些最受欢迎的包括Boost.Thread，QtConcurrent，Poco，TBB（Intel Threading Building Blocks）和C++11标准库中的std::thread。以下是一个使用C++11标准库中的线程池的示例代码：

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

class ThreadPool {
public:
    ThreadPool(int numThreads) : stop(false)
    {
        for (int i = 0; i < numThreads; ++i) {
           

相关问题

单例模式的线程池c++

以下是一个使用单例模式实现的线程池的C++示例：

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

class ThreadPool {
public:
    static ThreadPool& getInstance() {
        static ThreadPool instance;
        return instance;
    }

    void addTask(std::function<void()> task) {
        std::unique_lock<std::mutex> lock(mutex_);
        tasks_.push(task);
        condition_.notify_one();
    }

private:
    ThreadPool() {
        int numThreads = std::thread::hardware_concurrency();
        for (int i = 0; i < numThreads; ++i) {
            threads_.emplace_back([this]() {
                while (true) {
                    std::function<void()> task;
                    {
                        std::unique_lock<std::mutex> lock(mutex_);
                        condition_.wait(lock, [this]() {
                            return !tasks_.empty();
                        });
                        task = tasks_.front();
                        tasks_.pop();
                    }
                    task();
                }
            });
        }
    }

    ~ThreadPool() {
        {
            std::unique_lock<std::mutex> lock(mutex_);
            stop_ = true;
        }
        condition_.notify_all();
        for (std::thread& thread : threads_) {
            thread.join();
        }
    }

    ThreadPool(const ThreadPool&) = delete;
    ThreadPool& operator=(const ThreadPool&) = delete;

private:
    std::vector<std::thread> threads_;
    std::queue<std::function<void()>> tasks_;
    std::mutex mutex_;
    std::condition_variable condition_;
    bool stop_ = false;
};

// 使用示例
void task1() {
    std::cout << "Task 1 executed" << std::endl;
}

void task2() {
    std::cout << "Task 2 executed" << std::endl;
}

int main() {
    ThreadPool& threadPool = ThreadPool::getInstance();

    threadPool.addTask(task1);
    threadPool.addTask(task2);

    // 等待任务执行完成
    std::this_thread::sleep_for(std::chrono::seconds(1));

    return 0;
}

C++ 线程池

线程池是一种多线程处理方式，它可以通过预先创建一定数量的线程，来处理多个任务。这样可以避免过多的线程创建和销毁开销，提高程序性能和稳定性。以下是一个简单的 C++ 线程池实现示例：

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

class ThreadPool {
public:
    ThreadPool(int threads) : stop(false) {
        for (int i = 0; i < threads; ++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<class F>
    void enqueue(F &&f) {
        {
            std::unique_lock<std::mutex> lock(queue_mutex);
            tasks.emplace(std::forward<F>(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;
};

在这个实现中，我们使用了一个 `std::queue` 来存储任务，使用了一个互斥锁 `std::mutex` 来保护队列，使用了一个条件变量 `std::condition_variable` 来实现线程等待和唤醒。通过 `enqueue` 方法向线程池中添加任务，通过 `stop` 标识来控制线程池的停止。

使用线程池的示例代码：

ThreadPool pool(4);
std::vector<std::future<int>> results;

for (int i = 0; i < 8; ++i) {
    results.emplace_back(
            pool.enqueue([i] {
                std::cout << "hello " << i << std::endl;
                std::this_thread::sleep_for(std::chrono::seconds(1));
                std::cout << "world " << i << std::endl;
                return i * i;
            })
    );
}

for (std::future<int> &result: results)
    std::cout << result.get() << ' ';
std::cout << std::endl;

在这个示例中，我们创建了一个线程池 `ThreadPool pool(4)`，然后向线程池中添加了 8 个任务。每个任务都是一个 lambda 表达式，其中包含了两个输出语句和一个返回值。通过 `std::future` 来获取每个任务的返回值。最后输出所有任务的返回值。