How to implement thread safety in C++?

In a multi-threaded environment, it is crucial to achieve thread safety to avoid data corruption. The following mechanisms are provided in C++: 1. Mutex lock (std::mutex) ensures that only one thread is allowed to access shared data at a time; 2. Condition variable (std::condition_variable) allows threads to wait for a specific condition to be true; 3. Read-write lock (std::shared_mutex) allows multiple threads to read shared data simultaneously, but only one thread can write. These mechanisms ensure the stability and data integrity of programs in multi-threaded environments by synchronizing access to shared resources by different threads.

Thread-Safe Implementation in C++

Introduction

In a multi-threaded environment , if multiple threads access shared data simultaneously without synchronization, data corruption or application crashes may result. To prevent such problems, we need to implement thread safety.

Mutex lock

A mutex lock is a synchronization primitive that allows only one thread to access a certain part of code or data at a time. In C++, you can create a mutex lock using std::mutex as follows:

std::mutex m;

To obtain a mutex lock, use lock() Method:

m.lock();

Release the mutex lock when no longer needed:

m.unlock();

The advantage of the mutex lock is that it is simple and easy to use, but the disadvantage is that if a thread holds the mutex lock for a long time, It may take a long time for other threads to obtain the mutex lock.

Condition variables

Condition variables are used with mutex locks to allow a thread to wait for a certain condition to become true. In C++, you can create a condition variable using std::condition_variable as shown below:

std::condition_variable cv;

To wait on a condition variable, use the wait() method, Like this:

m.lock();
cv.wait(m);
m.unlock();

This will put the thread to sleep until another thread wakes it up using cv.notify_one() or cv.notify_all().

Read-write lock

Read-write lock is a special mutex lock that allows multiple threads to read shared data at the same time, but only one is allowed at a time Threads write shared data. In C++, you can use std::shared_mutex to create a read-write lock, as shown below:

std::shared_mutex rw;

To obtain a read lock, use the lock_shared() method :

rw.lock_shared();

To obtain the write lock, use lock() Method:

rw.lock();

Practical case

Assume we have A bank account class that tracks the account balance:

class BankAccount {
    std::mutex m;
    std::condition_variable cv;
    int balance;

public:
    int get_balance() {
        m.lock();
        int b = balance;
        m.unlock();
        return b;
    }

    void deposit(int amount) {
        m.lock();
        balance += amount;
        cv.notify_all();
        m.unlock();
    }

    void withdraw(int amount) {
        m.lock();
        while (balance < amount) {
            cv.wait(m);
        }
        balance -= amount;
        m.unlock();
    }
};

In this example, we use a mutex to protect the balance variable and a condition variable to allow the thread to wait when the balance is insufficient to satisfy the withdrawal.

The above is the detailed content of How to implement thread safety in C++?. For more information, please follow other related articles on the PHP Chinese website!