#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;
}