Thread-Pooling in C 11
Problem: Das wiederholte Erstellen und Löschen von Threads ist teuer. Wie können wir einen persistenten Thread-Pool zur Bearbeitung von Aufgaben einrichten, ohne dass dieser Overhead entsteht?
Lösung:
Implementierung der ThreadPool-Klasse
Um einen effizienten Thread-Pool zu erstellen, definieren wir zunächst den ThreadPool Klasse:
class ThreadPool { public: void Start(); void QueueJob(const std::function<void()>& job); void Stop(); bool busy(); private: void ThreadLoop(); bool should_terminate = false; std::mutex queue_mutex; std::condition_variable mutex_condition; std::vector<std::thread> threads; std::queue<std::function<void()>> jobs; };
1. ThreadPool::Start:
Erstellt eine feste Anzahl von Threads basierend auf den Systemfunktionen:
void ThreadPool::Start() { const uint32_t num_threads = std::thread::hardware_concurrency(); for (uint32_t ii = 0; ii < num_threads; ++ii) { threads.emplace_back(std::thread(&ThreadPool::ThreadLoop,this)) } }
2. ThreadPool::ThreadLoop:
Endlosschleife, die auf neue Aufgaben wartet:
void ThreadPool::ThreadLoop() { while (true) { std::function<void()> job; { std::unique_lock<std::mutex> lock(queue_mutex); mutex_condition.wait(lock, [this] { return !jobs.empty() || should_terminate; }); if (should_terminate) { return; } job = jobs.front(); jobs.pop(); } job(); } }
3. ThreadPool::QueueJob:
Fügt dem Pool eine neue Aufgabe hinzu:
void ThreadPool::QueueJob(const std::function<void()>& job) { { std::unique_lock<std::mutex> lock(queue_mutex); jobs.push(job); } mutex_condition.notify_one(); }
4. ThreadPool::busy:
Überprüft, ob der Pool aktive Jobs hat:
bool ThreadPool::busy() { bool poolbusy; { std::unique_lock<std::mutex> lock(queue_mutex); poolbusy = !jobs.empty(); } return poolbusy; }
5. ThreadPool::Stop:
Stoppt den Pool ordnungsgemäß:
void ThreadPool::Stop() { { std::unique_lock<std::mutex> lock(queue_mutex); should_terminate = true; } mutex_condition.notify_all(); for (std::thread& active_thread : threads) { active_thread.join(); } threads.clear(); }
Verwendung:
thread_pool->QueueJob([] { /* ... */ });
Diese Implementierung sorgt für eine Dynamik Thread-Pool, in dem Threads dauerhaft ausgeführt werden und darauf warten, dass Aufgaben hinzugefügt werden.
Das obige ist der detaillierte Inhalt vonWie kann ein Thread-Pool in C 11 effizient implementiert werden, um den Aufwand für die wiederholte Erstellung und Löschung von Threads zu vermeiden?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!