Pengaturcaraan Serentak C++: Bagaimana untuk menggunakan CPU berbilang teras untuk mencapai konkurensi?

C++ pengaturcaraan serentak memanfaatkan sepenuhnya CPU berbilang teras dengan mencipta benang, mutex dan pembolehubah keadaan. Mencipta benang membolehkan tugasan dilaksanakan secara selari. Mutex bertindak sebagai kunci untuk memastikan data yang dikongsi tidak diakses oleh berbilang benang secara serentak, dengan itu mengelakkan rasuah data. Pembolehubah keadaan digunakan untuk memberitahu urutan bahawa syarat tertentu telah dipenuhi, dan digunakan dengan kunci mutex untuk menghalang utas daripada terus melaksanakan sehingga syarat dipenuhi.

Pengaturcaraan Serentak dalam C++: Membuka kunci CPU Berbilang Teras

Prakata

CPU moden selalunya mempunyai berbilang teras, dan dengan menggunakan sepenuhnya kod pemotongan ini, kami boleh meningkatkan kecekapan kod ini dengan ketara. C++ menyediakan pelbagai alat pengaturcaraan serentak yang membolehkan pengaturcara membuat aplikasi dengan mudah yang boleh melaksanakan pelbagai tugas secara serentak.

Mencipta Benang

Mencipta Benang ialah blok binaan asas yang mewakili konkurensi. Dalam C++, anda boleh mencipta urutan baharu menggunakan kelas std::thread. Ia menerima sebagai hujah objek boleh dipanggil yang menentukan tugas yang akan dilakukan dalam benang berasingan. 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

Dalam kod di atas, fungsi hello_world() ialah objek boleh panggil yang hanya mencetak mesej ke konsol. Pembina std::thread mencipta utas baharu dan melaksanakan objek boleh panggil. thread1.join() menyekat urutan utama sehingga urutan baharu selesai. 🎜🎜🎜Mutex lock🎜🎜🎜Mutex lock adalah sangat penting apabila urutan mengakses data kongsi secara serentak. Mereka bertindak sebagai kunci untuk menghalang berbilang benang daripada mengakses bahagian kritikal secara serentak, dengan itu mengelakkan rasuah data. Dalam C++, anda boleh mencipta kunci mutex menggunakan kelas std::mutex. 🎜rrreee🎜Dalam contoh ini, fungsi increment() menambah pembolehubah kongsi counter. Kami menggunakan std::lock_guard untuk mendapatkan kunci mutex, memastikan hanya satu utas boleh melaksanakan bahagian kritikal pada masa yang sama. Mekanisme ini memastikan bahawa dua urutan tidak menambah counter pada masa yang sama, sekali gus mengelakkan perlumbaan data. 🎜🎜🎜Pembolehubah bersyarat🎜🎜🎜Pembolehubah bersyarat digunakan untuk memberitahu urutan bahawa syarat tertentu telah dipenuhi. Ia digunakan dengan kunci mutex untuk memastikan bahawa benang tidak meneruskan pelaksanaan sehingga syarat dipenuhi. Dalam C++, pembolehubah keadaan boleh dibuat menggunakan kelas std::condition_variable. 🎜rrreee🎜Dalam contoh ini, kami menggunakan pembolehubah keadaan untuk menyelaraskan interaksi antara rangkaian pengeluar dan pengguna. Fungsi producer() menetapkan bendera kongsi sedia kepada benar dan memberitahu urutan pengguna. Fungsi consumer() menunggu bendera kongsi menjadi benar dengan menunggu pada pembolehubah syarat sebelum meneruskan pelaksanaan. 🎜

Atas ialah kandungan terperinci Pengaturcaraan Serentak C++: Bagaimana untuk menggunakan CPU berbilang teras untuk mencapai konkurensi?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!