C++ concurrent programming: how to perform thread synchronization and mutual exclusion?

Thread synchronization is crucial when multiple threads access shared resources concurrently. C provides mutexes, condition variables, and atomic operations to achieve synchronization. Mutexes ensure that only one thread can access a resource at a time; condition variables are used for inter-thread communication; and atomic operations ensure that a single operation can be executed uninterrupted. For example, use mutexes to synchronize access to shared queues to prevent data corruption.

C Concurrent Programming: Thread Synchronization and Mutual Exclusion

Overview

Threads Synchronization is key to ensuring data integrity is maintained when multiple threads access shared resources simultaneously. C provides a variety of mechanisms for thread synchronization, including mutexes, condition variables, and atomic operations.

Mutex (Mutex)

A mutex is an object that allows only one thread to access a shared resource at a time. The mutex is used as follows:

std::mutex m;

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

std::lock_guard is a RAII type that represents the lock on the mutex. When the func() function is executed, the lock will be automatically released.

Condition Variable

Condition variable is used for communication between threads. It allows one thread to wait until another thread meets certain conditions. The usage is as follows:

std::condition_variable cv;

void wait() {
  std::unique_lock<std::mutex> lock(m);
  cv.wait(lock);  // 等待条件变量
}

void notify() {
  std::unique_lock<std::mutex> lock(m);
  cv.notify_one();  // 通知等待的线程
}

std::unique_lock represents an exclusive lock on the mutex. When the wait() function is called, the thread will be blocked until the notify_one() function is called.

Atomic operation

Atomic operation is a low-level synchronization mechanism that ensures that a single operation can be executed without interruption. The usage is as follows:

std::atomic<int> counter;

void increment() {
  counter++;  // 原子地递增计数器
}

Practical case

Consider a scenario where multiple threads are accessing a shared queue, and the queue size has an upper limit. To prevent threads from accessing the queue at the same time and causing data corruption, we can use a mutex to synchronize access to the queue:

std::mutex m;
std::queue<int> queue;
const int MAX_SIZE = 10;  // 队列最大容量

void producer() {
  while (true) {
    std::lock_guard<std::mutex> lock(m);
    if (queue.size() < MAX_SIZE) {
      queue.push(rand());
    }
  }
}

void consumer() {
  while (true) {
    std::lock_guard<std::mutex> lock(m);
    if (!queue.empty()) {
      std::cout << queue.front() << std::endl;
      queue.pop();
    }
  }
}

The above is the detailed content of C++ concurrent programming: how to perform thread synchronization and mutual exclusion?. For more information, please follow other related articles on the PHP Chinese website!