c++线程池例子
摘要：本文将介绍C++线程池的基本概念，并提供一个简单的示例，以展示如何使用C++11标准库中的线程库来创建和管理线程池。
正文：线程池是一种管理线程的技术，它可以在需要时创建新线程，并在不再需要时回收线程。这种技术可以有效地提高程序的性能，降低资源消耗，并减少线程创建和销毁的开销。在C++中，可以使用C++11标准库中的线程库来实现线程池。
以下是一个简单的C++线程池示例：
```cpp
#include <iostream>
#include <queue>
#include <mutex>
#include <condition_variable>
#include <thread>
#include <stdexcept>
class ThreadPool {
public:
    ThreadPool(size_t threadCount) : threads_(threadCount) {
        workQueue_.reserve(kInitialQueueSize);
    }
    ~ThreadPool() {
        shutdown_ = true;
        {
            std::unique_lock<std::mutex> lock(mtx_);
            cv_.wait(lock, [] { return !jobs_.empty(); });
        }
        for (auto& job : jobs_) {
            job.second();
        }
        jobs_.clear();
    }
    void submit(const std::function<void()>& job) {
        std::unique_lock<std::mutex> lock(mtx_);
        jobs_.push(job);
        cv_.notify_one();
    }
private:
    static constexpr std::size_t kInitialQueueSize = 10;
    std::mutex mtx_;
    std::condition_variable cv_;
thread技术
    std::queue<std::function<void()>> workQueue_;
    std::vector<std::thread> threads_;
    std::atomic<bool> shutdown_{false};
};
int main() {
    ThreadPool pool(4);
    pool.submit([&pool] {
        while (!pool.shutdown()) {
            std::function<void()> job;
            {
                std::unique_lock<std::mutex> _);
                pool.cv_.wait(lock, [] { return !pool.jobs_.empty(); });
                job = std::move(pool.jobs_.front());
                pool.jobs_.pop();
            }
            job(); // Do
        }
    });
    // Let the main thread do some
    return 0;
}
```
在这个示例中，我们创建了一个名为`ThreadPool`的类，它接受一个线程计数参数。类中包含一个工作队列`jobs_`，用于存储待处理的任务。还有一个线程数组`threads_`，用于创建和管理线程。当提交一个新的任务时，该任务将被添加到工作队列中。主线程将循环地从工作队列中获取任务并执行，直到关闭线程池。
在`main`函数中，我们创建了一个`ThreadPool`实例，并创建了一个辅助线程来处理任务。这个辅助线程会一直运行，直到主线程关闭线程池。这样，主线程可以执行其他任务，而无需等待辅助线程完成。
这个示例展示了如何使用C++11标准库中的线程库来创建和管理线程池。当然，实际的线程池实现可能会涉及到更多的细节，例如错误处理、资源管理等。但这个示例应该足以帮助你理解C++线程池的基本概念。
在上面的示例中，我们创建了一个简单的线程池，它包含一个工作线程，该线程从任务队列中获取任务并执行。这个线程会一直运行，直到线程池被关闭。这种实现非常简单，但也存在一些问题。例如，如果任务队列中的任务非常多，那么这个工作线程可能会非常忙，导致其他线程无法执行任务。此外，如果任务非常少，那么这个工作线程可能会非常空闲，导致资源浪费。
为了解决这些问题，我们可以使用`std::async`来创建新的工作线程，而不是使用循环和条件变量。这样，我们可以根据系统的负载来动态地创建和销毁工作线程。此外，我们还可以使用`std::promise`和`std::future`来确保每个任务都在其完成时被执行。
以下是一个改进后的示例：
```cpp
#include <iostream>
#include <queue>
#include <mutex>
#include <condition_variable>
#include <thread>
#include <stdexcept>
#include <future>
class ThreadPool {
public:
    ThreadPool(size_t threadCount) : threads_(threadCount) {}
    template <typename Function>
    std::future<decltype(Function())> submit(Function function) {

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。