C++ Concurrent Programming: Wie kann man mit einer Multi-Core-CPU Parallelität erreichen?

Die gleichzeitige C++-Programmierung nutzt Multi-Core-CPUs voll aus, indem Threads, Mutexe und Bedingungsvariablen erstellt werden. Durch das Erstellen von Threads können Aufgaben parallel ausgeführt werden. Ein Mutex fungiert als Sperre, um sicherzustellen, dass nicht mehrere Threads gleichzeitig auf gemeinsam genutzte Daten zugreifen und so eine Datenbeschädigung vermieden wird. Bedingungsvariablen werden verwendet, um einem Thread mitzuteilen, dass eine bestimmte Bedingung erfüllt ist, und werden mit Mutex-Sperren verwendet, um zu verhindern, dass ein Thread weiter ausgeführt wird, bis die Bedingung erfüllt ist.

Gleichzeitige Programmierung in C++: Mehrkern-CPUs freischalten

Vorwort

Moderne CPUs verfügen oft über mehrere Kerne, und durch die vollständige Nutzung dieser Kerne können wir die Codeeffizienz bei der parallelen Ausführung von Aufgaben erheblich verbessern. C++ bietet eine Vielzahl von Tools für die gleichzeitige Programmierung, mit denen Programmierer problemlos Anwendungen erstellen können, die mehrere Aufgaben gleichzeitig ausführen können.

Threads erstellen

Threads erstellen sind die Grundbausteine ​​zur Darstellung der Parallelität. In C++ können Sie neue Threads mithilfe der Klasse std::thread erstellen. Es akzeptiert als Argument ein aufrufbares Objekt, das die Aufgabe angibt, die in einem separaten Thread ausgeführt werden soll. std::thread 类创建新线程。它接受一个可调用对象作为参数，该对象指定在单独的线程中执行的任务。

#include <iostream>
#include <thread>

void hello_world() {
  std::cout << "Hello, world!" << std::endl;
}

int main() {
  std::thread thread1(hello_world);
  thread1.join();

  return 0;
}

在上面的代码中，hello_world() 函数是一个可调用对象，它只需向控制台打印一条消息。std::thread 构造函数创建一个新线程并执行可调用对象。thread1.join() 阻塞主线程，直到新线程完成。

互斥锁

线程并发访问共享数据时，互斥锁非常重要。它们充当锁，防止多个线程同时访问关键部分，从而避免数据损坏。在 C++ 中，可以使用 std::mutex 类创建互斥锁。

#include <iostream>
#include <thread>
#include <mutex>

std::mutex m;  // 全局互斥锁

void increment(int& counter) {
  std::lock_guard<std::mutex> lock(m);  // 获取互斥锁
  ++counter;
}

int main() {
  int counter = 0;

  std::thread thread1(increment, std::ref(counter));
  std::thread thread2(increment, std::ref(counter));

  thread1.join();
  thread2.join();

  std::cout << "Final counter value: " << counter << std::endl;

  return 0;
}

在这个示例中，increment() 函数对共享变量 counter 进行递增。我们使用 std::lock_guard 来获取互斥锁，确保只有一个线程可以同时执行关键部分。这种机制确保两个线程不会同时递增 counter，从而避免数据竞争。

条件变量

条件变量用于通知线程特定条件已满足。它们与互斥锁一起使用，以确保线程在满足条件之前不会继续执行。在 C++ 中，可以使用 std::condition_variable 类创建条件变量。

#include <iostream>
#include <thread>
#include <condition_variable>
#include <mutex>

std::mutex m;  // 全局互斥锁
std::condition_variable cv;  // 全局条件变量
bool ready = false;  // 共享布尔标志

void producer() {
  std::lock_guard<std::mutex> lock(m);  // 获取互斥锁
  ready = true;                       // 设置共享标志为 true
  cv.notify_one();                   // 通知一个等待的线程
}

void consumer() {
  std::unique_lock<std::mutex> lock(m);  // 获取互斥锁（并锁定它）
  while (!ready)                        // 等待共享标志为 true
    cv.wait(lock);                     // 释放互斥锁并等待
}

int main() {
  std::thread producer_thread(producer);
  std::thread consumer_thread(consumer);

  producer_thread.join();
  consumer_thread.join();

  return 0;
}

在此示例中，我们使用条件变量来协调生产者和消费者线程之间的交互。producer() 函数设置共享标志 ready 为 true 并通知消费者线程。consumer()rrreee

Im obigen Code ist die Funktion hello_world() ein aufrufbares Objekt, das einfach eine Nachricht an die Konsole druckt. Der std::thread-Konstruktor erstellt einen neuen Thread und führt das aufrufbare Objekt aus. thread1.join() blockiert den Hauptthread, bis der neue Thread abgeschlossen ist. 🎜🎜🎜Mutex-Sperre🎜🎜🎜Mutex-Sperre ist sehr wichtig, wenn Threads gleichzeitig auf gemeinsam genutzte Daten zugreifen. Sie fungieren als Sperren, um zu verhindern, dass mehrere Threads gleichzeitig auf kritische Abschnitte zugreifen, und verhindern so eine Datenbeschädigung. In C++ können Sie eine Mutex-Sperre mithilfe der Klasse std::mutex erstellen. 🎜rrreee🎜In diesem Beispiel erhöht die Funktion increment() die gemeinsam genutzte Variable counter. Wir verwenden std::lock_guard, um eine Mutex-Sperre zu erhalten und so sicherzustellen, dass nur ein Thread den kritischen Abschnitt gleichzeitig ausführen kann. Dieser Mechanismus stellt sicher, dass nicht zwei Threads gleichzeitig den Zähler erhöhen, wodurch Datenwettläufe vermieden werden. 🎜🎜🎜Bedingte Variablen🎜🎜🎜Bedingte Variablen werden verwendet, um Threads zu benachrichtigen, dass eine bestimmte Bedingung erfüllt wurde. Sie werden mit Mutex-Sperren verwendet, um sicherzustellen, dass Threads nicht mit der Ausführung fortfahren, bis eine Bedingung erfüllt ist. In C++ können Bedingungsvariablen mit der Klasse std::condition_variable erstellt werden. 🎜rrreee🎜In diesem Beispiel verwenden wir Bedingungsvariablen, um die Interaktion zwischen Producer- und Consumer-Threads zu koordinieren. Die Funktion producer() setzt das Shared-Flag ready auf true und benachrichtigt den Consumer-Thread. Die Funktion consumer() wartet darauf, dass das gemeinsame Flag wahr ist, indem sie auf eine Bedingungsvariable wartet, bevor sie mit der Ausführung fortfährt. 🎜

Das obige ist der detaillierte Inhalt vonC++ Concurrent Programming: Wie kann man mit einer Multi-Core-CPU Parallelität erreichen?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!