Gängige Entwurfsmuster in der gleichzeitigen C++-Programmierung

Bei der gleichzeitigen C++-Programmierung kann die Übernahme von Entwurfsmustern die Lesbarkeit, Wartbarkeit und Skalierbarkeit des Codes verbessern. Zu den gängigen Mustern gehören: Producer-Consumer-Muster: Ein Thread generiert Daten und andere Threads verbrauchen Daten. Leser-Schreiber-Modus: Mehrere Leser können gleichzeitig auf freigegebene Ressourcen zugreifen, aber nur ein Autor kann darauf zugreifen. Überwachungsmodus: Schützt den gleichzeitigen Zugriff auf gemeinsam genutzte Ressourcen, erzwingt Synchronisierung und Statusprüfungen. Thread-Pool-Modus: Erstellen Sie Thread-Gruppen im Voraus, um den Aufwand durch häufiges Erstellen und Zerstören von Threads zu vermeiden.

Gemeinsame Entwurfsmuster in der gleichzeitigen C++-Programmierung

Bei der gleichzeitigen Programmierung kann die Verwendung von Entwurfsmustern die Lesbarkeit, Wartbarkeit und Skalierbarkeit des Codes erheblich verbessern. Nachfolgend sind einige gängige Muster in der gleichzeitigen C++-Programmierung aufgeführt:

Produzenten-Konsumenten-Muster

In diesem Muster generiert ein Produzenten-Thread Daten und ein oder mehrere Konsumenten-Threads verbrauchen die Daten. Gängige Implementierungsmethoden sind die Verwendung von Warteschlangen oder Shared Memory.

Beispiel:

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

Reader-Writer-Modus

In diesem Modus können mehrere Leser gleichzeitig auf gemeinsame Ressourcen zugreifen, aber nur ein Autor kann darauf zugreifen. Wiedereintrittssperren oder Lese-/Schreibsperren werden häufig zur Implementierung dieses Musters verwendet.

Beispiel:

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

Monitormuster

Das Monitormuster schützt den gleichzeitigen Zugriff auf gemeinsam genutzte Ressourcen, indem es den Datenzugriff auf ein einzelnes Objekt beschränkt. Überwachungsobjekte kapseln Daten und Vorgänge und erzwingen die Synchronisierung und Statusprüfung.

Beispiel:

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

Thread-Pool-Modus

Der Thread-Pool-Modus bietet eine vorab erstellte Thread-Gruppe, die von Client-Threads verwendet werden kann. Durch die Verwendung eines Thread-Pools können Sie den Aufwand vermeiden, der durch das häufige Erstellen und Zerstören von Threads entsteht.

Beispiel:

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

Das obige ist der detaillierte Inhalt vonGängige Entwurfsmuster in der gleichzeitigen C++-Programmierung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!