Programmation simultanée C++ : comment effectuer la planification des tâches et la gestion du pool de threads ?

La planification des tâches et la gestion du pool de threads sont les clés pour améliorer l'efficacité et l'évolutivité de la programmation simultanée C++. Planification des tâches : utilisez std::thread pour créer de nouveaux threads. Utilisez la méthode join() pour rejoindre un fil de discussion. Gestion du pool de threads : Créez un objet ThreadPool et spécifiez le nombre de threads. Ajoutez des tâches à l'aide de la méthode add_task(). Appelez la méthode join() ou stop() pour arrêter le pool de threads.

Programmation simultanée C++ : planification des tâches et gestion du pool de threads

Introduction

Dans la programmation simultanée, la planification des tâches et la gestion du pool de threads sont cruciales pour améliorer l'efficacité et l'évolutivité des applications. Cet article vous guidera à travers le concept de planification des tâches en C++ et montrera comment utiliser std::thread et std::mutex dans la norme C++11 pour gérer pools de threads. std::thread 和 std::mutex 来管理线程池。

任务调度

任务调度涉及分配和执行异步任务。在 C++ 中，可以使用 std::thread 来创建新线程：

std::thread t([]() {
  // 执行异步任务
});

要加入线程，请使用 join() 方法：

t.join();

线程池管理

线程池是一个预先创建并管理的线程集合，可用于处理任务。使用线程池可以避免反复创建和销毁线程的开销。

以下是如何在 C++ 中创建和管理线程池：

class ThreadPool {
public:
  ThreadPool(int num_threads) {
    for (int i = 0; i < num_threads; i++) {
      threads_.emplace_back(std::thread([this]() { this->thread_loop(); }));
    }
  }

  void thread_loop() {
    while (true) {
      std::function<void()> task;

      {
        std::lock_guard<std::mutex> lock(mtx_);
        if (tasks_.empty()) {
          continue;
        }

        task = tasks_.front();
        tasks_.pop();
      }

      task();
    }
  }

  void add_task(std::function<void()> task) {
    std::lock_guard<std::mutex> lock(mtx_);
    tasks_.push(task);
  }

  void stop() {
    std::unique_lock<std::mutex> lock(mtx_);
    stop_ = true;
  }

  ~ThreadPool() {
    stop();

    for (auto& t : threads_) {
      t.join();
    }
  }

private:
  std::vector<std::thread> threads_;
  std::queue<std::function<void()>> tasks_;
  std::mutex mtx_;
  bool stop_ = false;
};

要使用线程池，可以执行以下步骤：

1. 创建一个线程池对象，指定要创建的线程数。
2. 使用 add_task() 方法将任务添加到线程池。
3. 调用 join() 或 stop() 方法来关闭线程池并等待所有任务完成。

实战案例

以下是一个使用线程池在多核系统上执行并发任务的示例：

#include <iostream>
#include <vector>
#include "thread_pool.h"

int main() {
  ThreadPool pool(4);

  std::vector<std::future<int>> futures;
  for (int i = 0; i < 10000; i++) {
    futures.push_back(pool.add_task([i]() { return i * i; }));
  }

  for (auto& f : futures) {
    std::cout << f.get() << std::endl;
  }

  return 0;
}

结论

通过使用 std::thread

🎜Planification des tâches🎜🎜🎜La planification des tâches implique l'allocation et l'exécution de tâches asynchrones. En C++, vous pouvez utiliser std::thread pour créer un nouveau fil de discussion : 🎜rrreee🎜Pour rejoindre un fil de discussion, utilisez la méthode join() : 🎜rrreee🎜🎜Thread gestion du pool 🎜🎜🎜Un pool de threads est un ensemble de threads pré-créés et gérés qui peuvent être utilisés pour traiter des tâches. L’utilisation d’un pool de threads évite la surcharge liée à la création et à la destruction répétées de threads. 🎜🎜Voici comment créer et gérer un pool de threads en C++ : 🎜rrreee🎜Pour utiliser un pool de threads, vous pouvez effectuer les étapes suivantes : 🎜

1. Créez un objet pool de threads, en spécifiant le nombre de threads à créer .
2. Utilisez la méthode add_task() pour ajouter des tâches au pool de threads.
3. Appelez la méthode join() ou stop() pour fermer le pool de threads et attendez que toutes les tâches soient terminées.

🎜🎜Cas pratique🎜🎜🎜Ce qui suit est un exemple d'utilisation d'un pool de threads pour effectuer des tâches simultanées sur un système multicœur : 🎜rrreee🎜🎜Conclusion🎜🎜🎜En utilisant std ::thread code> et pool de threads, peuvent gérer efficacement les tâches simultanées en C++. Qu'il s'agisse de calcul scientifique sur des systèmes multicœurs ou de services Web devant traiter un grand nombre de requêtes, la planification des threads et la gestion des pools de threads sont essentielles pour améliorer l'efficacité et l'évolutivité du code. 🎜

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!