Bagaimana untuk menangani kawalan konkurensi dalam reka bentuk kelas C++?

Kawalan konkurensi dalam C++ menggunakan mekanisme seperti mutex (satu akses kepada bahagian kritikal), pembolehubah keadaan (menunggu syarat untuk dipenuhi), kunci baca-tulis (membenarkan berbilang pembaca membaca pada masa yang sama, tetapi hanya satu untuk menulis) untuk menyelesaikan sumber yang dikongsi Perlumbaan data dan keadaan tidak konsisten yang disebabkan oleh akses serentak.

Concurrency Control dalam Reka Bentuk Kelas C++

Pengenalan

Dalam persekitaran berbilang benang, akses serentak kepada sumber yang dikongsi mungkin membawa kepada perlumbaan data dan keadaan tidak konsisten. Untuk menyelesaikan masalah ini, C++ menyediakan pelbagai mekanisme untuk mengendalikan kawalan serentak.

Mutex

Mutex ialah primitif penyegerakan yang membenarkan hanya satu urutan mengakses bahagian kritikal pada satu masa. Kita boleh menggunakan kelas std::mutex untuk mencipta mutex: std::mutex 类来创建一个互斥量：

std::mutex mutex;

要访问临界区，线程必须获取互斥量的锁：

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

条件变量

条件变量是一个同步原语，它允许一个线程等待另一个线程完成特定的条件。我们可以使用 std::condition_variable 类来创建一个条件变量：

std::condition_variable cv;

线程可以通过调用 wait() 方法来等待条件：

cv.wait(mutex);

当条件满足时，另一個執行緒可以呼叫 notify_one() 或 notify_all() 方法來通知等待的執行緒：

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

读写锁

读写锁是一种同步原语，它允许多个线程同时读取共享资源，但一次只有一个线程可以写入共享资源。我们可以使用 std::shared_mutex

std::shared_mutex rw_mutex;

Untuk mengakses bahagian kritikal, benang mesti memperoleh kunci mutex:

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

Pembolehubah keadaan

Pembolehubah keadaan ialah primitif Penyegerakan yang membenarkan satu utas menunggu untuk utas lain menyelesaikan syarat tertentu. Kita boleh menggunakan kelas std::condition_variable untuk mencipta pembolehubah keadaan:

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

Threads boleh menunggu syarat dengan memanggil kaedah wait():

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;
};

Apabila syarat telah dipenuhi , urutan lain boleh memanggil kaedah notify_one() atau notify_all() untuk memberitahu urutan menunggu:

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;
};

kunci baca-tulis

baca-tulis kunci ialah primitif Penyegerakan yang membenarkan berbilang utas membaca daripada sumber yang dikongsi secara serentak, tetapi hanya satu utas boleh menulis kepada sumber yang dikongsi pada satu masa. Kita boleh menggunakan kelas std::shared_mutex untuk membuat kunci baca-tulis: 🎜rrreee🎜Untuk membaca sumber yang dikongsi, utas boleh memperoleh kunci baca: 🎜rrreee🎜Untuk menulis kepada sumber yang dikongsi, utas boleh memperoleh tulisan kunci :🎜rrreee🎜Kes praktikal🎜🎜Pertimbangkan kelas akaun bank mudah yang mengandungi pembolehubah ahli baki dan kaedah untuk deposit dan pengeluaran:🎜rrreee🎜Untuk mengendalikan akses serentak, kita boleh menggunakan mutex untuk melindungi Pembolehubah ahli baki: 🎜 rrreee🎜 Kini kami boleh mengakses akaun bank dengan selamat serentak dari pelbagai rangkaian. 🎜

Atas ialah kandungan terperinci Bagaimana untuk menangani kawalan konkurensi dalam reka bentuk kelas C++?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!