Wie funktioniert Thread-Pooling in C 11?

Thread-Pooling in C 11

Einführung

Thread-Pooling ist eine Technik zur Verwaltung von a Satz von Threads, denen dynamisch Aufgaben zugewiesen werden können. Es bietet mehrere Vorteile gegenüber dem Erstellen und Zerstören von Threads für jede Aufgabe, einschließlich verbesserter Leistung und Ressourceneffizienz.

Thread-Pooling verstehen

In C 11 ist normalerweise ein Thread-Pool vorhanden implementiert mithilfe einer Kombination aus Threads, Mutexes und Bedingungsvariablen. Threads werden im Hintergrund erstellt und gestartet und Aufgaben werden einer Warteschlange hinzugefügt. Die Mitarbeiter überwachen ständig die Warteschlange und warten darauf, dass neue Aufgaben verfügbar werden. Sobald eine Aufgabe verfügbar ist, ruft ein Worker sie ab und führt sie aus.

Erstellen eines Thread-Pools

Um einen Thread-Pool zu erstellen, können wir eine ThreadPool-Klasse definieren:

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

Den Thread verwalten Pool

• Start: Startet den Thread-Pool durch Erstellen und Starten der Arbeitsthreads.
• QueueJob: Fügt einen neuen hinzu Aufgabe in die Warteschlange stellen, damit die Arbeiter sie ausführen können.
• Stop: Stoppt den Thread-Pool, indem er ein Beendigungsflag für die Arbeiter setzt und darauf wartet, dass sie fertig werden.
• busy: Überprüft, ob der Thread-Pool beschäftigt ist (d. h. Aufgaben in der Warteschlange hat).

Worker-Thread-Schleife

Jeder Worker-Thread führt eine Endlosschleife aus, um auf die Ausführung zu warten Aufgaben:

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();
    }
}

Verwenden des Thread-Pools

Um den Thread-Pool zu verwenden, erstellen Sie einfach eine Instanz und rufen Sie QueueJob auf, um Aufgaben hinzuzufügen:

ThreadPool thread_pool;
thread_pool.Start();
thread_pool.QueueJob([] { /* ... */ });

Vorteile des Thread-Poolings

• Verbessert Leistung: Durch die Wiederverwendung von Threads entfällt der Aufwand für das Erstellen und Zerstören von Threads für jede Aufgabe.
• Ressourceneffizienz: Die Anzahl der Threads im Pool kann an die Arbeitslast angepasst werden, wodurch Ressourcen gespart werden.
• Vereinfachter Code: Thread-Pooling abstrahiert die Verwaltung von Threads und macht Ihren Code prägnanter und einfacher zu warten.

Das obige ist der detaillierte Inhalt vonWie funktioniert Thread-Pooling in C 11?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!