Corak reka bentuk biasa dalam pengaturcaraan serentak C++

Dalam pengaturcaraan serentak C++, mengamalkan corak reka bentuk boleh meningkatkan kebolehbacaan, kebolehselenggaraan dan kebolehskalaan kod Corak biasa termasuk: corak pengeluar-pengguna: satu utas menjana data dan urutan lain menggunakan data. Mod pembaca-penulis: Berbilang pembaca boleh mengakses sumber yang dikongsi pada masa yang sama, tetapi hanya seorang penulis boleh mengaksesnya. Mod monitor: melindungi akses serentak kepada sumber yang dikongsi, menguatkuasakan penyegerakan dan semakan status. Mod kumpulan benang: Buat kumpulan benang terlebih dahulu untuk mengelakkan overhed kerap mencipta dan memusnahkan benang.

Corak reka bentuk biasa dalam pengaturcaraan serentak C++

Dalam pengaturcaraan serentak, menggunakan corak reka bentuk boleh meningkatkan kebolehbacaan, kebolehselenggaraan dan kebolehskalaan kod dengan ketara. Di bawah disenaraikan beberapa corak biasa dalam pengaturcaraan serentak C++:

Corak Pengeluar-Pengguna

Dalam corak ini, satu urutan pengeluar menjana data dan satu atau lebih rangkaian pengguna menggunakan data. Kaedah pelaksanaan biasa menggunakan baris gilir atau memori dikongsi.

Contoh:

class Producer {
public:
    void produce(const T& data) {
        std::lock_guard<std::mutex> lock(queue_mutex);
        queue.push(data);
    }
private:
    std::queue<T> queue;
    std::mutex queue_mutex;
};

class Consumer {
public:
    void consume() {
        std::unique_lock<std::mutex> lock(queue_mutex);
        if (queue.empty()) {
            condition_variable.wait(lock);
        }
        const T& data = queue.front();
        queue.pop();
        lock.unlock();
        // ...
    }
private:
    std::shared_ptr<Producer> producer;
    std::condition_variable condition_variable;
    std::mutex queue_mutex;
};

Mod Pembaca-Penulis

Mod ini membenarkan berbilang pembaca mengakses sumber dikongsi pada masa yang sama, tetapi hanya seorang penulis boleh mengaksesnya. Kunci reentrant atau kunci baca-tulis sering digunakan untuk melaksanakan corak ini.

Contoh:

class ReadWriteLock {
public:
    void read_lock() {
        while (write_locked) {
            unique_lock<std::mutex> lock(read_mutex);
            read_count++;
        }
    }

    void read_unlock() {
        std::lock_guard<std::mutex> lock(read_mutex);
        read_count--;
    }

    void write_lock() {
        std::lock_guard<std::mutex> lock(write_mutex);
        while (read_count > 0) { /* 等待读完成 */}
        write_locked = true;
    }

    void write_unlock() {
        std::lock_guard<std::mutex> lock(write_mutex);
        write_locked = false;
    }

private:
    bool write_locked = false;
    int read_count = 0;
    std::mutex read_mutex;
    std::mutex write_mutex;
};

Pola Pantau

Corak monitor melindungi akses serentak kepada sumber dikongsi dengan mengehadkan akses data kepada satu objek. Pantau objek merangkum data dan operasi serta menguatkuasakan penyegerakan dan semakan status.

Contoh:

class Account {
public:
    void deposit(int amount) {
        std::lock_guard<std::mutex> lock(balance_mutex);
        balance += amount;
    }

    int withdraw(int amount) {
        std::lock_guard<std::mutex> lock(balance_mutex);
        if (amount <= balance) {
            balance -= amount;
            return amount;
        }
        return 0;
    }

    int get_balance() {
        std::lock_guard<std::mutex> lock(balance_mutex);
        return balance;
    }

private:
    int balance = 0;
    std::mutex balance_mutex;
};

Mod Kolam Benang

Mod Kolam Benang menyediakan kumpulan benang pra-dicipta untuk digunakan oleh urutan pelanggan. Dengan menggunakan kumpulan benang, anda boleh mengelakkan overhed untuk kerap mencipta dan memusnahkan benang.

Contoh:

class ThreadPool {
public:
    ThreadPool(int num_threads) {
        for (int i = 0; i < num_threads; i++) {
            threads.emplace_back(std::thread([this] {
                while (true) {
                    std::function<void()> task;
                    {
                        std::unique_lock<std::mutex> lock(tasks_mutex);
                        if (tasks.empty()) {
                            condition_variable.wait(lock);
                        }
                        task = std::move(tasks.front());
                        tasks.pop();
                    }
                    task();
                }
            }));
        }
    }

    void submit(std::function<void()> task) {
        std::lock_guard<std::mutex> lock(tasks_mutex);
        tasks.push(std::move(task));
        condition_variable.notify_one();
    }

private:
    std::vector<std::jthread> threads;
    std::queue<std::function<void()>> tasks;
    std::mutex tasks_mutex;
    std::condition_variable condition_variable;
};

Atas ialah kandungan terperinci Corak reka bentuk biasa dalam pengaturcaraan serentak C++. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!