Comment implémenter efficacement un pool de threads dans C 11 pour éviter les frais généraux de création et de suppression de threads répétés ?

Thread Pooling en C 11

Problème : Créer et supprimer des threads à plusieurs reprises coûte cher. Comment pouvons-nous établir un pool de threads persistant pour gérer les tâches sans encourir cette surcharge ?

Solution :

Implémentation de la classe ThreadPool

Pour créer un pool de threads efficace, nous définissons d'abord le ThreadPool classe :

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 :

Crée un nombre fixe de threads en fonction des capacités du système :

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:

Boucle sans fin qui attend de nouvelles 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();
    }
}

3. ThreadPool::QueueJob:

Ajoute une nouvelle tâche au pool :

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:

Vérifie si le pool a des tâches actives :

bool ThreadPool::busy() {
    bool poolbusy;
    {
        std::unique_lock<std::mutex> lock(queue_mutex);
        poolbusy = !jobs.empty();
    }
    return poolbusy;
}

5. ThreadPool::Stop :

Arrête gracieusement le pool :

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

Utilisation :

thread_pool->QueueJob([] { /* ... */ });

Cette implémentation fournit une pool de threads où les threads s'exécutent de manière persistante et attendent que les tâches soient ajoutées.

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!