Heim > Backend-Entwicklung > C++ > Wie 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?

Wie 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?

Patricia Arquette
Freigeben: 2024-12-13 14:27:11
Original
528 Leute haben es durchsucht

How to Efficiently Implement a Thread Pool in C  11 to Avoid Repeated Thread Creation and Deletion Overhead?

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;
};
Nach dem Login kopieren

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))
    }
}
Nach dem Login kopieren

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();
    }
}
Nach dem Login kopieren

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();
}
Nach dem Login kopieren

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;
}
Nach dem Login kopieren

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();
}
Nach dem Login kopieren

Verwendung:

thread_pool->QueueJob([] { /* ... */ });
Nach dem Login kopieren

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!

Quelle:php.cn
Erklärung dieser Website
Der Inhalt dieses Artikels wird freiwillig von Internetnutzern beigesteuert und das Urheberrecht liegt beim ursprünglichen Autor. Diese Website übernimmt keine entsprechende rechtliche Verantwortung. Wenn Sie Inhalte finden, bei denen der Verdacht eines Plagiats oder einer Rechtsverletzung besteht, wenden Sie sich bitte an admin@php.cn
Neueste Artikel des Autors
Beliebte Tutorials
Mehr>
Neueste Downloads
Mehr>
Web-Effekte
Quellcode der Website
Website-Materialien
Frontend-Vorlage