线程池的C++11和posix库实现方式

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

class ThreadPool {
public:
    ThreadPool(size_t num_threads);
    ~ThreadPool();

    void enqueue(std::function<void()> task);

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

    void workerThread();
};

ThreadPool::ThreadPool(size_t num_threads) : stop(false) {
    for (size_t i = 0; i < num_threads; ++i) {
        workers.emplace_back(&ThreadPool::workerThread, this);
    }
}

ThreadPool::~ThreadPool() {
    stop = true;
    condition.notify_all();

    for (std::thread &worker : workers) {
        worker.join();
    }
}

void ThreadPool::enqueue(std::function<void()> task) {
    {
        std::unique_lock<std::mutex> lock(queue_mutex);
        tasks.push(task);
    }
    condition.notify_one();
}

void ThreadPool::workerThread() {
    while (!stop) {
        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 = tasks.front();
            tasks.pop();
        }
        task();
    }
}

#include <iostream>
#include <vector>
#include <queue>
#include <pthread.h>
#include <functional>

class ThreadPool {
public:
    ThreadPool(size_t num_threads);
    ~ThreadPool();

    void enqueue(std::function<void()> task);

private:
    static void* workerThread(void* arg);

    std::vector<pthread_t> workers;
    std::queue<std::function<void()>> tasks;
    pthread_mutex_t queue_mutex;
    pthread_cond_t condition;
    bool stop;

};

ThreadPool::ThreadPool(size_t num_threads) : stop(false) {
    pthread_mutex_init(&queue_mutex, nullptr);
    pthread_cond_init(&condition, nullptr);

    for (size_t i = 0; i < num_threads; ++i) {
        pthread_t thread;
        pthread_create(&thread, nullptr, &ThreadPool::workerThread, this);
        workers.push_back(thread);
    }
}

ThreadPool::~ThreadPool() {
    stop = true;
    pthread_cond_broadcast(&condition);

    for (pthread_t worker : workers) {
        pthread_join(worker, nullptr);
    }

    pthread_mutex_destroy(&queue_mutex);
    pthread_cond_destroy(&condition);
}

void ThreadPool::enqueue(std::function<void()> task) {
    pthread_mutex_lock(&queue_mutex);
    tasks.push(task);
    pthread_mutex_unlock(&queue_mutex);

    pthread_cond_signal(&condition);
}

void* ThreadPool::workerThread(void* arg) {
    ThreadPool* pool = static_cast<ThreadPool*>(arg);

    while (!pool->stop) {
        std::function<void()> task;
        pthread_mutex_lock(&pool->queue_mutex);

        while (pool->tasks.empty() && !pool->stop) {
            pthread_cond_wait(&pool->condition, &pool->queue_mutex);
        }

        if (pool->stop && pool->tasks.empty()) {
            pthread_mutex_unlock(&pool->queue_mutex);
            return nullptr;
        }

        task = pool->tasks.front();
        pool->tasks.pop();
        pthread_mutex_unlock(&pool->queue_mutex);

        task();
    }

    return nullptr;
}