Comment implémenter une programmation multithread à l'aide de la bibliothèque de threads standard C++ ?

La programmation multithread améliore l'efficacité en exécutant des tâches en parallèle. Les étapes pour implémenter le multithreading à l'aide de la bibliothèque de threads standard C++ sont les suivantes : Utilisez std::thread pour créer un thread et transmettre un objet appelable (fonction lambda ou fonction). pointeur) comme paramètre du constructeur. Attendez que le thread se termine en appelant la méthode join(), bloquant le thread principal jusqu'à ce que le thread enfant termine son exécution. Cas pratique : Calculer les nombres premiers en parallèle, allouer la plage de calcul à plusieurs threads et attendre sa fin, et imprimer la liste des nombres premiers après avoir fusionné les résultats.

Utilisez la bibliothèque de threads standard C++ pour implémenter la programmation multithread

La programmation multithread améliore l'efficacité du programme en exécutant plusieurs tâches en parallèle. Cet article présentera comment utiliser la bibliothèque de threads standard C++ pour implémenter facilement une programmation multithread, et l'illustrera à travers des cas pratiques.

Création de threads

Pour créer un thread, vous pouvez utiliser la classe std::thread, qui reçoit une référence à un objet appelable en tant que paramètre de son constructeur. Un objet appelable est généralement une fonction lambda ou un pointeur de fonction. Par exemple : std::thread 类，它接收一个可调用对象的引用作为其构造函数的参数。可调用对象通常是一个 lambda 函数或一个函数指针。例如：

// 定义一个函数指针
void thread_function() {
  // ... 执行此线程应执行的任务
}

// 创建线程
std::thread t(thread_function);

等待线程终止

创建线程后，主线程可以通过调用 join() 方法等待其终止。join()

// 等待子线程完成
t.join();

En attente de la fin du thread

Après avoir créé un thread, le thread principal peut attendre sa fin en appelant la méthode join(). La méthode join() bloque le thread principal jusqu'à ce que le thread de création, appelé thread enfant, termine son exécution. Par exemple :

#include <iostream>
#include <vector>
#include <thread>

bool is_prime(int n) {
  if (n < 2) {
    return false;
  }
  for (int i = 2; i <= n / 2; ++i) {
    if (n % i == 0) {
      return false;
    }
  }
  return true;
}

std::vector<int> find_primes(int start, int end) {
  std::vector<int> primes;
  for (int i = start; i <= end; ++i) {
    if (is_prime(i)) {
      primes.push_back(i);
    }
  }
  return primes;
}

int main() {
  int start = 1;
  int end = 1000000;
  int num_threads = 4;

  // 分配计算范围
  int range_size = (end - start) / num_threads;
  std::vector<std::thread> threads;
  std::vector<std::vector<int>> primes_list;
  for (int i = 0; i < num_threads; ++i) {
    int thread_start = start + i * range_size;
    int thread_end = thread_start + range_size - 1;
    threads.emplace_back(std::thread(find_primes, thread_start, thread_end));
  }

  // 等待线程完成并合并结果
  for (auto& thread : threads) {
    std::vector<int> primes;
    thread.join();
    thread.get(primes);
    primes_list.push_back(primes);
  }

  std::vector<int> primes;
  for (auto& list : primes_list) {
    primes.insert(primes.end(), list.begin(), list.end());
  }

  // 打印素数列表
  for (int prime : primes) {
    std::cout << prime << " ";
  }
  std::cout << std::endl;

  return 0;
}

Cas pratique : Calcul parallèle de nombres premiers

Démontrons la programmation multithread à travers un cas pratique. Nous allons écrire un programme qui utilise plusieurs threads pour calculer en parallèle des nombres premiers dans une plage donnée.

rrreeeL'exécution de ce programme affichera tous les nombres premiers dans la plage donnée.

🎜🎜🎜Remarque : 🎜Ce didacticiel présente les concepts de base et les applications pratiques de la programmation multithread à l'aide de la bibliothèque de threads standard C++. Pour des fonctionnalités plus avancées et des bonnes pratiques, il est recommandé de consulter la documentation de la bibliothèque standard C++ et les ressources en ligne. 🎜

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!