What are the common thread synchronization mechanisms in C++ multi-threaded programming?

C++ In multi-threaded programming, thread synchronization mechanisms are essential. There are three main types: Mutex locks (Mutex): used to protect exclusive access to shared resources. Condition Variable: Used to notify the thread that a specific condition has been met. Read-Write Lock: Allows multiple threads to read shared data at the same time, but only one thread can write at a time.

Thread synchronization mechanism in C++ multi-threaded programming

In multi-threaded programming, the synchronization mechanism is important to avoid data competition and ensure Thread safety is crucial. The following are some common thread synchronization mechanisms in C++:

Mutex (Mutex)

Mutex is a low-level synchronization mechanism used to protect shared resources exclusive access. It allows only one thread to access critical sections (blocks of code that require synchronization) at a time.

std::mutex m;

void critical_section() {
  std::lock_guard<std::mutex> lock(m);
  // 临界区代码
}

Condition Variable

Condition variable is used to notify one thread that another thread meets a specific condition. One thread can wait for a condition using the wait() method, while another thread can signal it using the notify_one() or notify_all() method.

std::condition_variable cv;
bool condition_met = false;

void wait_for_condition() {
  std::unique_lock<std::mutex> lock(m);
  cv.wait(lock, []() { return condition_met; });
}

void signal_condition() {
  std::lock_guard<std::mutex> lock(m);
  condition_met = true;
  cv.notify_one();
}

Read-Write Lock(Read-Write Lock)

Read-Write Lock allows multiple threads to read shared data at the same time, but only one thread can write at a time Share data.

std::shared_lock<std::shared_mutex> lock(m, std::shared_lock<std::shared_mutex>::defer_lock);

Practical case: shared counter

Consider a shared counter that needs to support the increment and acquisition operations of multiple threads at the same time:

class SharedCounter {
  std::mutex mutex_;
  int count_;

public:
  void increment() {
    std::lock_guard<std::mutex> lock(mutex_);
    ++count_;
  }

  int get() {
    std::lock_guard<std::mutex> lock(mutex_);
    return count_;
  }
};

In In this example, the mutex_ mutex is used to protect the count_ variable. Each thread can independently increment the counter via the increment() method, and can read the current value via the get() method.

The above is the detailed content of What are the common thread synchronization mechanisms in C++ multi-threaded programming?. For more information, please follow other related articles on the PHP Chinese website!