C++ 동시 프로그래밍의 일반적인 디자인 패턴

C++ 동시 프로그래밍에서 디자인 패턴을 채택하면 코드의 가독성, 유지 관리성 및 확장성이 향상될 수 있습니다. 일반적인 패턴은 다음과 같습니다. 생산자-소비자 패턴: 한 스레드는 데이터를 생성하고 다른 스레드는 데이터를 소비합니다. 리더-라이터 모드: 여러 리더가 동시에 공유 리소스에 액세스할 수 있지만 작성자는 한 명만 액세스할 수 있습니다. 모니터 모드: 공유 리소스에 대한 동시 액세스를 보호하고 동기화 및 상태 확인을 시행합니다. 스레드 풀 모드: 스레드 그룹을 미리 생성하여 스레드를 자주 생성하고 삭제하는 오버헤드를 방지합니다.

C++ 동시 프로그래밍의 일반적인 디자인 패턴

동시 프로그래밍에서 디자인 패턴을 사용하면 코드의 가독성, 유지 관리성 및 확장성을 크게 향상시킬 수 있습니다. 아래에는 C++ 동시 프로그래밍의 몇 가지 일반적인 패턴이 나열되어 있습니다.

생산자-소비자 패턴

이 패턴에서는 하나의 생산자 스레드가 데이터를 생성하고 하나 이상의 소비자 스레드가 데이터를 소비합니다. 일반적인 구현 방법은 대기열이나 공유 메모리를 사용하는 것입니다.

예:

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 모드

이 모드를 사용하면 여러 독자가 동시에 공유 리소스에 액세스할 수 있지만 작성자는 한 명만 액세스할 수 있습니다. 재진입 잠금 또는 읽기-쓰기 잠금은 이 패턴을 구현하는 데 자주 사용됩니다.

예:

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

모니터 패턴

모니터 패턴은 단일 개체에 대한 데이터 액세스를 제한하여 공유 리소스에 대한 동시 액세스를 보호합니다. 모니터 개체는 데이터와 작업을 캡슐화하고 동기화 및 상태 확인을 시행합니다.

예:

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

스레드 풀 모드

스레드 풀 모드는 클라이언트 스레드에서 사용할 사전 생성된 스레드 그룹을 제공합니다. 스레드 풀을 사용하면 스레드를 자주 생성하고 삭제하는 오버헤드를 피할 수 있습니다.

예:

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

위 내용은 C++ 동시 프로그래밍의 일반적인 디자인 패턴의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!