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 ?-C++-php.cn

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 ?

Patricia Arquette

Libérer： 2024-12-13 14:27:11

original

528 Les gens l'ont consulté

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

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

Copier après la connexion

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

Copier après la connexion

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

Copier après la connexion

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

Copier après la connexion

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

Copier après la connexion

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

Copier après la connexion

Utilisation :

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

Copier après la connexion

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!