在下面的代码中，我们的任务是使用多线程创建一个消费者/生产者程序，并找到一种防止死锁的方法。

#include <iostream>
#include <stack>
#include <time.h>
#include <mutex>
#include <condition_variable>
#include <random>
#include <thread>
#include <windows.h>
#include <algorithm>
#include <stack>

#define MAX 100
#define MIN 0

std::condition_variable cv;
std::mutex mtx;

class ProducerConsumer{

    public:

        // Creates a stack
        std::stack<int> stack_array;

        // Facilitates checking of values
        int producer_sum = 0;
        int consumer_sum = 0;

        // Generates random number
        int random_number_generator(){
            std::random_device rd;
            std::default_random_engine re{rd()};

            return re();
        }

        // Produces values and pushes them into the stack       
        void producer(){
            for (int i = 0 ; i < MAX ; i++){

                std::unique_lock<std::mutex> lg(mtx);

                if (stack_array.size() == MAX){
                    std::cout << "Producer Thread " << std::this_thread::get_id() << " is waiting" << std::endl;
                    cv.wait(lg);
                }

                int rand_num = random_number_generator()%10+1;
                int rand_num_sleep = random_number_generator()%100+1;
                
                std::cout << "Current Stack Size -  " << stack_array.size() <<  " | Pushing: " << rand_num << "... " << "and sleeping for: " << rand_num_sleep << " milliseconds" << std::endl;

                producer_sum += rand_num;

                stack_array.push(rand_num); 

                std::this_thread::sleep_for(std::chrono::milliseconds(rand_num_sleep)); 
                
                cv.notify_all();
                lg.unlock();
            }
        }

        void consumer(){
            for (int i = 0 ; i < MAX ; i++) {

                std::unique_lock<std::mutex> lg(mtx);

                if (stack_array.size() == MIN){
                    std::cout << "Consumer Thread " << std::this_thread::get_id() << " is waiting" << std::endl;
                    cv.wait(lg);
                }

                int rand_num_sleep = random_number_generator()%100+1;
            
                std::cout << "Current Stack Size - " << stack_array.size() << " | Popping: " << stack_array.top() << "... " << "and sleeping for: " << rand_num_sleep << " milliseconds" << std::endl;

                consumer_sum += stack_array.top();

                stack_array.pop();  

                std::this_thread::sleep_for(std::chrono::milliseconds(rand_num_sleep));
                
                cv.notify_all();
                lg.unlock();
            }

        }
};

int main(){

    ProducerConsumer pc;

    std::thread producer_one (&ProducerConsumer::producer, &pc);
    std::thread consumer_one (&ProducerConsumer::consumer, &pc);
    std::thread producer_two (&ProducerConsumer::producer, &pc);
    std::thread consumer_two (&ProducerConsumer::consumer, &pc);

    producer_one.join();
    producer_two.join();
    consumer_one.join();
    consumer_two.join();

    std::cout << "Producer sum: " << pc.producer_sum << std::endl;
    std::cout << "Consumer sum: " << pc.consumer_sum << std::endl;
    std::cout << "Stack size: " << pc.stack_array.size() << std::endl;
}

当尝试运行代码时，有时候代码会遇到死锁，因为我认为程序是从生产者线程开始的（这是可以理解的，因为我没有编写一种方法来绕过它）。但有时候，代码运行得很好。其他时候，程序会遇到分段错误或在执行过程中遇到死锁。
我假设我的互斥实现是条件变量是正确的。如果不是，谁能解释一下我的代码有什么问题吗？任何帮助都是感激的。非常感谢！