How to deal with concurrency control in C++ class design?

Concurrency control in C uses mechanisms such as mutexes (accessing critical sections at one time), condition variables (waiting for conditions to be met), read-write locks (allowing multiple readers to read at the same time, but only one write) to solve the problem. Data races and inconsistent states caused by concurrent access to shared resources.

Concurrency control in C class design

Introduction

In a multi-threaded environment, concurrent access to shared resources may cause data Contested and inconsistent states. To solve this problem, C provides several mechanisms to handle concurrency control.

Mutex

A mutex is a synchronization primitive that allows only one thread to access a critical section at a time. We can use the std::mutex class to create a mutex:

std::mutex mutex;

To access the critical section, the thread must acquire the lock of the mutex:

mutex.lock();
// 访问临界区
mutex.unlock();

Conditions Variable

A condition variable is a synchronization primitive that allows one thread to wait for another thread to complete a specific condition. We can use the std::condition_variable class to create a condition variable:

std::condition_variable cv;

Threads can wait for conditions by calling the wait() method:

cv.wait(mutex);

When the conditions are met, another thread can call the notify_one() or notify_all() method to notify the waiting thread:

cv.notify_one();
cv.notify_all();

Read-write lock

Read-write lock is a synchronization primitive that allows multiple threads to read shared resources at the same time, but only one thread can write to shared resources at a time. We can use the std::shared_mutex class to create a read-write lock:

std::shared_mutex rw_mutex;

To read shared resources, the thread can acquire a read lock:

rw_mutex.lock_shared();
// 读取共享资源
rw_mutex.unlock_shared();

To write to the share Resources, threads can acquire write locks:

rw_mutex.lock();
// 写入共享资源
rw_mutex.unlock();

Practical case

Consider a simple bank account class, which contains a balance member variable and a method for deposits and withdrawals:

class BankAccount {
public:
    BankAccount(int initial_balance) : balance(initial_balance) {}
    
    void deposit(int amount) {
        balance += amount;
    }
    
    void withdraw(int amount) {
        if (amount <= balance) {
            balance -= amount;
        }
    }
    
private:
    int balance;
};

To handle concurrent access, we can use a mutex to protect the balance member variable:

class BankAccount {
public:
    BankAccount(int initial_balance) : balance(initial_balance) {}
    
    void deposit(int amount) {
        std::lock_guard<std::mutex> lock(mutex);
        balance += amount;
    }
    
    void withdraw(int amount) {
        std::lock_guard<std::mutex> lock(mutex);
        if (amount <= balance) {
            balance -= amount;
        }
    }
    
private:
    std::mutex mutex;
    int balance;
};

Now, we can safely access the bank account concurrently from multiple threads.

The above is the detailed content of How to deal with concurrency control in C++ class design?. For more information, please follow other related articles on the PHP Chinese website!