Comment fonctionne le pooling de threads dans C 11 ?

Thread Pooling en C 11

Introduction

Le thread pooling est une technique de gestion d'un ensemble de threads auxquels des tâches peuvent être assignées dynamiquement. Il offre plusieurs avantages par rapport à la création et à la destruction de threads sur chaque tâche, notamment des performances améliorées et une efficacité des ressources.

Comprendre le pool de threads

En C 11, un pool de threads est généralement implémenté en utilisant une combinaison de threads, de mutex et de variables de condition. Les threads sont créés et démarrés en arrière-plan, et les tâches sont ajoutées à une file d'attente. Les travailleurs surveillent constamment la file d’attente, attendant que de nouvelles tâches soient disponibles. Une fois qu'une tâche est disponible, un travailleur la récupérera et l'exécutera.

Création d'un pool de threads

Pour créer un pool de threads, nous pouvons définir une classe ThreadPool :

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

Gérer le fil de discussion Pool

• Démarrer : Démarre le pool de threads en créant et en démarrant les threads de travail.
• QueueJob : Ajoute un nouveau tâche à la file d'attente pour que les travailleurs l'exécutent.
• Arrêter : Arrête le pool de threads en définissant un indicateur de fin pour les travailleurs et en attendant qu'ils terminent.
• busy : Vérifie si le pool de threads est occupé (c'est-à-dire s'il a des tâches dans la file d'attente).

Boucle de thread de travail

Chaque thread de travail exécute une boucle infinie pour attendre et exécuter tâches :

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

Utilisation du pool de threads

Pour utiliser le pool de threads, créez simplement une instance et appelez QueueJob pour ajouter des tâches :

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

Avantages du pooling de threads

• Amélioré performances : en réutilisant les threads, nous éliminons les frais généraux liés à la création et à la destruction de threads pour chaque tâche.
• Efficacité des ressources : le nombre de threads dans le pool peut être ajusté en fonction de la charge de travail, économisant ainsi des ressources.
• Code simplifié : le pooling de threads simplifie la gestion des threads, rendant votre code plus concis et plus facile à maintenir.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!