Bagaimana untuk melaksanakan keselamatan benang dalam reka bentuk kelas C++?

Untuk mencapai keselamatan benang, terdapat dua kaedah dalam C++: Gunakan mutex untuk melindungi bahagian kritikal, membenarkan hanya satu benang mengaksesnya pada satu masa. Menggunakan operasi atom, operasi dilakukan dalam cara yang tidak boleh dibahagikan, menghapuskan isu akses serentak.

Melaksanakan keselamatan benang dalam reka bentuk kelas C++

Pengenalan

Dalam persekitaran berbilang benang, adalah penting untuk memastikan keselamatan rangkaian data. Terdapat beberapa cara untuk mencapai ini dalam C++. Artikel ini akan meneroka cara menggunakan mutex dan operasi atom untuk mereka bentuk kelas selamat benang.

Mutex

Mutex ialah mekanisme penguncian yang membenarkan hanya satu utas mengakses bahagian kritikal pada satu masa. Apabila benang memasuki bahagian kritikal, ia memperoleh pemilikan mutex. Benang lain yang cuba memasuki bahagian kritikal akan disekat sehingga benang mengeluarkan mutex.

class ThreadSafeCounter {
private:
    std::mutex m_mutex;
    int m_count;

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

    int get() {
        std::lock_guard<std::mutex> lock(m_mutex);
        return m_count;
    }
};

Dalam contoh di atas, kedua-dua kaedah increment() dan get() menggunakan std::mutex daripada perpustakaan standard untuk melindungi daerah kritikal. Semasa satu utas sedang mengemas kini kiraan, utas lain tidak boleh memasukkan kaedah increment() pada masa yang sama. increment() 和 get() 方法都使用标准库中的 std::mutex 保护临界区。当一个线程正在更新计数时，其他线程无法同时进入 increment() 方法。

原子操作

原子操作是一种特殊类型的操作，它以不可分割的方式执行。这意味着一次只能在单个线程中执行这些操作，从而消除了并发访问引发的问题。C++11 中引入了 std::atomic 库，它提供了用于原子操作的类。

class ThreadSafeCounterAtomic {
private:
    std::atomic<int> m_count;

public:
    void increment() {
        ++m_count;
    }

    int get() {
        return m_count.load();
    }
};

在本例中，m_count 是一个原子整数，可以安全地从多个线程中进行增量和获取。std::atomic<int>::load()

Operasi Atom

Operasi atom ialah jenis operasi khas yang dilakukan dengan cara yang tidak boleh dibahagi-bahagikan. Ini bermakna bahawa operasi ini hanya boleh dilakukan dalam satu utas pada satu masa, menghapuskan masalah yang disebabkan oleh akses serentak. C++11 memperkenalkan perpustakaan std::atomic, yang menyediakan kelas untuk operasi atom.

#include <thread>

int main() {
    std::unique_ptr<ThreadSafeCounter> counter = std::make_unique<ThreadSafeCounter>();

    std::vector<std::thread> threads(10);
    for (auto& thread : threads) {
        thread = std::thread([&] {
            for (int i = 0; i < 1000000; ++i) {
                counter->increment();
            }
        });
    }

    for (auto& thread : threads) {
        thread.join();
    }

    std::cout << "最终计数：" << counter->get() << std::endl;
}

Dalam kes ini, m_count ialah integer atom yang boleh ditambah dengan selamat dan diambil daripada berbilang urutan. Kaedah std::atomic<int>::load() memperoleh nilai integer atom dengan cara selamat benang.

Kes Praktikal

Pertimbangkan contoh kaunter kongsi yang perlu dikemas kini secara selari daripada berbilang rangkaian:

rrreee

Dalam program ini, kami mengemas kini kaunter selari daripada 10 utas dan kemudian mencetak kiraan akhir dalam benang utama. Mutex memastikan bahawa kaunter hanya boleh dikemas kini oleh paling banyak satu utas pada bila-bila masa, sekali gus memastikan keselamatan benang. 🎜🎜🎜Kesimpulan🎜🎜🎜Kelas C++ selamat benang boleh direka bentuk dengan menggunakan mutex dan operasi atom. Mutexes sesuai untuk melindungi bahagian kritikal yang memerlukan akses bersiri, manakala operasi atom sesuai untuk operasi yang tidak memerlukan akses bersiri dan boleh dilakukan secara atom. 🎜

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