Bagaimana untuk melaksanakan struktur data dan algoritma serentak dalam C++?

Bagaimana untuk melaksanakan struktur data dan algoritma serentak dalam C++?

Dalam pengaturcaraan serentak, penggunaan struktur data dan algoritma yang betul adalah sangat penting. Dalam C++, kita boleh menggunakan pelbagai kaedah untuk melaksanakan struktur dan algoritma data serentak, termasuk menggunakan kunci mutex, pembolehubah keadaan, operasi atom, dsb.

1. Gunakan kunci mutex
Kunci mutex ialah mekanisme kawalan serentak yang paling asas dicapai dengan mengunci sumber yang dikongsi dan kemudian mengawal akses. Dalam C++, kita boleh menggunakan std::mutex untuk melaksanakan kunci mutex.

Sebagai contoh, kita boleh menggunakan kunci mutex untuk melaksanakan baris gilir selamat benang yang mudah:

#include <mutex>
#include <queue>

template<typename T>
class ConcurrentQueue {
private:
    std::queue<T> q;
    std::mutex mtx;

public:
    void push(const T& value) {
        std::lock_guard<std::mutex> lock(mtx);
        q.push(value);
    }

    T pop() {
        std::lock_guard<std::mutex> lock(mtx);
        if (q.empty())
            throw std::runtime_error("Queue is empty");
        T value = q.front();
        q.pop();
        return value;
    }

    bool empty() {
        std::lock_guard<std::mutex> lock(mtx);
        return q.empty();
    }
};

Dalam kod di atas, kami menggunakan std::mutex untuk melindungi operasi baris gilir dan mengurus mutex secara automatik melalui std::lock_guard Mengunci dan membuka kunci. Ini memastikan bahawa apabila beberapa utas mengakses baris gilir pada masa yang sama, hanya satu utas yang mengendalikan baris gilir.

2. Gunakan pembolehubah keadaan
Pembolehubah keadaan ialah cara lain untuk melaksanakan struktur data dan algoritma serentak dalam C++. Pembolehubah keadaan boleh digunakan untuk penyegerakan dan komunikasi antara benang.

Sebagai contoh, kita boleh menggunakan pembolehubah keadaan untuk melaksanakan baris gilir selamat benang yang mudah Apabila baris gilir kosong, utas pengguna akan menunggu dan menyekat sehingga data baharu dimasukkan ke dalam baris gilir oleh benang pengeluar.

#include <mutex>
#include <queue>
#include <condition_variable>

template<typename T>
class ConcurrentQueue {
private:
    std::queue<T> q;
    std::mutex mtx;
    std::condition_variable cv;

public:
    void push(const T& value) {
        std::lock_guard<std::mutex> lock(mtx);
        q.push(value);
        cv.notify_one();
    }

    T pop() {
        std::unique_lock<std::mutex> lock(mtx);
        cv.wait(lock, [this] { return !q.empty(); });
        T value = q.front();
        q.pop();
        return value;
    }

    bool empty() {
        std::lock_guard<std::mutex> lock(mtx);
        return q.empty();
    }
};

Dalam kod di atas, kami menggunakan std::condition_variable untuk melaksanakan operasi menunggu dan pemberitahuan. Apabila baris gilir kosong, urutan pengguna memanggil fungsi cv.wait() untuk menunggu sehingga data baharu dimasukkan ke dalam baris gilir oleh urutan pengeluar, dan kemudian fungsi cv.notify_one() memberitahu urutan pengguna untuk meneruskan pelaksanaan.

3. Gunakan operasi atom
Operasi atom ialah kaedah operasi khas yang memastikan operasi pada sumber yang dikongsi tidak terganggu. C++11 memperkenalkan satu siri antara muka operasi atom yang boleh digunakan untuk melaksanakan struktur dan algoritma data serentak yang cekap.

Sebagai contoh, kita boleh menggunakan operasi atom untuk melaksanakan pembilang selamat benang mudah:

#include <atomic>

class ConcurrentCounter {
private:
    std::atomic<int> count;

public:
    ConcurrentCounter() : count(0) {}

    int increment() {
        return count.fetch_add(1) + 1;
    }

    int decrement() {
        return count.fetch_sub(1) - 1;
    }

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

Dalam kod di atas, kami menggunakan std::atomic untuk mengisytiharkan pembolehubah atom melalui std::atomic::fetch_add() dan std Fungsi ::atomic::fetch_sub() menjalankan operasi atom pada kaunter untuk memastikan keselamatan benang.

Ringkasan:
Melaksanakan struktur data dan algoritma serentak dalam C++ ialah tugas yang kompleks dan penting. Kita boleh menggunakan kunci mutex, pembolehubah keadaan, operasi atom dan banyak kaedah lain untuk memastikan keselamatan benang. Apabila mereka bentuk struktur dan algoritma data serentak, kita perlu mempertimbangkan sepenuhnya keseimbangan antara ketekalan data dan keselarasan, serta mengelakkan masalah biasa dalam pengaturcaraan serentak seperti kebuntuan dan keadaan perlumbaan.

Atas ialah kandungan terperinci Bagaimana untuk melaksanakan struktur data dan algoritma serentak dalam C++?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!