Pengaturcaraan Serentak C++: Bagaimana untuk mengendalikan komunikasi antara benang?

Kaedah untuk komunikasi antara benang dalam C++ termasuk: memori dikongsi, mekanisme penyegerakan (kunci mutex, pembolehubah keadaan), paip dan baris gilir mesej. Contohnya, gunakan kunci mutex untuk melindungi pembilang yang dikongsi: mengisytiharkan kunci mutex (m) dan pembolehubah yang dikongsi (pembilang); untuk mengelakkan keadaan perlumbaan.

Pengaturcaraan Serentak C++: Bagaimana untuk mengendalikan komunikasi antara benang?

Dalam aplikasi berbilang benang, benang perlu dapat berkomunikasi antara satu sama lain untuk menyelaraskan tugas dan berkongsi data. C++ menyediakan pelbagai mekanisme untuk melaksanakan komunikasi antara benang, termasuk:

Memori dikongsi

Menggunakan memori dikongsi, berbilang benang boleh mengakses kawasan memori yang sama. Ini adalah pendekatan overhed rendah, tetapi penjagaan perlu diambil untuk mengelakkan keadaan perlumbaan.

int shared_data = 0;

void thread_1() {
  shared_data++; // 可能会被其他线程同时访问
}

void thread_2() {
  shared_data++; // 可能会同时导致不正确的结果
}

Mekanisme penyegerakan

Mekanisme penyegerakan boleh digunakan untuk menyelaraskan urutan apabila mengakses sumber yang dikongsi.

Mutex (Mutex)

Mutex menyediakan akses eksklusif bersama, memastikan hanya satu utas boleh mengakses sumber yang dikongsi pada satu masa.

std::mutex m;

void thread_1() {
  std::lock_guard<std::mutex> l(m); // 获取互斥锁
  // 访问共享资源
}

void thread_2() {
  std::lock_guard<std::mutex> l(m); // 获取互斥锁
  // 访问共享资源
}

Pembolehubah Keadaan

Pembolehubah keadaan membolehkan benang menunggu untuk syarat tertentu dipenuhi.

std::condition_variable cv;
std::mutex m;

void producer() {
  std::lock_guard<std::mutex> l(m); // 获取互斥锁
  while (!condition) {
    // 等待条件满足
    cv.wait(l);
  }
  // 生产数据
}

void consumer() {
  std::lock_guard<std::mutex> l(m); // 获取互斥锁
  condition = true;
  cv.notify_all(); // 唤醒所有等待线程
}

Paip

Paip ialah mekanisme komunikasi satu arah yang digunakan untuk memindahkan data antara dua utas.

std::pipe pipe;

void writer() {
  std::string message = "hello";
  std::write(pipe[1], message.c_str(), message.length());
}

void reader() {
  std::string message;
  std::read(pipe[0], message.data(), message.size());
}

Baris Gilir Mesej

Baris Gilir Mesej menyediakan mekanisme penghantaran mesej tak segerak.

key_t key = ftok("message_queue", 'a');

int message_queue = msgget(key, IPC_CREAT | 0666);

void sender() {
  Message msg;
  msg.mtext = "hello";
  msgsnd(message_queue, &msg, sizeof(msg.mtext), IPC_NOWAIT);
}

void receiver() {
  Message msg;
  msgrcv(message_queue, &msg, sizeof(msg.mtext), 0, 0);
}

Kes praktikal: Menggunakan mutex untuk melindungi kaunter kongsi

Andaikan kita mempunyai kaunter kongsi yang perlu dikemas kini secara serentak oleh berbilang rangkaian. Kita boleh melindungi kaunter ini menggunakan mutex:

std::mutex m;
int counter = 0;

void thread_1() {
  for (int i = 0; i < 1000000; i++) {
    std::lock_guard<std::mutex> l(m);
    counter++;
  }
}

void thread_2() {
  for (int i = 0; i < 1000000; i++) {
    std::lock_guard<std::mutex> l(m);
    counter--;
  }
}

Ini memastikan hanya satu utas boleh mengemas kini kaunter pada bila-bila masa, sekali gus menghalang keadaan perlumbaan.

Atas ialah kandungan terperinci Pengaturcaraan Serentak C++: Bagaimana untuk mengendalikan komunikasi antara benang?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!