C++ 如何决定我需要多少互斥锁？

在这里，我对2个条件变量使用了2个互斥体。如何确定一个互斥量是否足够，或者需要单独的互斥量

资料来源：

#include "thread_class.h"

#include <unistd.h>
#include <mutex>
#include <queue>
#include <condition_variable>
#include <iostream>

// Thread_manager class: ***************************************************************************************************************
std::queue<int> queue_m;

std::mutex mutex_k;

bool watch;

std::mutex mutex_x;
std::mutex mutex_y;

std::condition_variable cv_x;
std::condition_variable cv_y;

ThreadManager::ThreadManager() : obj_thread_B_( &B::Run, &obj_class_B_),
                                 obj_thread_A_( &A::Run, &obj_class_A_ )
{
    watch = false;
}

ThreadManager::~ThreadManager()
{
    obj_thread_A_.join();
    obj_thread_B_.join();
}

void A::Run()
{
    while( 1 )
    {
        std::unique_lock<std::mutex> lk( mutex_x );
        while (watch == false)
            cv_x.wait( lk );

        std::cout << "\nA class\n";

        someint++;
        queue_m.push( someint );

        cv_y.notify_all();

        // some time consuming operation
        for (int t = 0; t < 1000000; t++)
        {
        }
    }
}

void B::Run()
{
    while( 1 )
    {
        std::cout << "\nB class\n";

        if (queue_m.size() > 0)
        {
            int temp = queue_m.front();
            std::cout << "\nTaken out: " << temp;
            queue_m.pop();

            cv_x.notify_all();
        }
        else
        {
            std::unique_lock<std::mutex> lk( mutex_y );
            watch = true;

            cv_x.notify_all();

            cv_y.wait( lk );
        }
     }
}

#包括“thread_class.h”
#包括
#包括
#包括
#包括
#包括
//线程管理器类：***************************************************************************************************************
std:：queue-queue\m；
std:：mutex mutex_k；
布尔手表；
std:：mutex mutex_x；
std:：mutex mutex_y；
std：：条件变量cv_x；
std：：条件变量cv_y；
ThreadManager:：ThreadManager（）：obj_thread_B_（&B:：Run，&obj_class_B_），
obj_线程A_（&A:：运行，&obj_类A_）
{
手表=假；
}
ThreadManager:：~ThreadManager（）
{
对象线程连接（）；
obj_螺纹连接（）；
}
void A:：Run（）
{
而(1)
{
std:：unique_lock lk（互斥锁）；
while（watch==false）
等速等待（lk）；
std:：cout这取决于进程中
竞态条件的总数。根据进程中不同的
竞态条件
，您将决定处理所有
竞态条件所需的互斥量。请阅读下面的答案，这将有助于您了解
竞态条件

这取决于进程中
竞争条件的总数。根据进程中不同的
竞争条件
，您将决定处理所有
竞争条件所需的互斥锁数量。请阅读下面的答案，这将有助于您理解
竞争条件de>

：这取决于你有多少比赛条件。这里有更多的细节来确定这一点

拿出一张纸。在右边，列出页面上所有受保护的资源，您希望在使用时保证任何线程以独占方式访问这些资源
在页面的左侧，列出页面上可能需要这些资源的所有线程。如果您只知道它将是>1个线程，您可以只写“线程1”和“线程2”来表示无限多的线程

从左边的每个线程到右边它需要的所有资源绘制一个箭头
圈出右侧有多个箭头指向单个资源的所有箭头交叉点。计算圆圈的数量。这就是此模块的竞争条件，这就是您需要的独立互斥量
我刚刚起草了一个例子。这个例子有3个竞争条件（注意3个圆圈），因此需要3个单独的互斥锁：


现在评估左侧：您是否可以通过将多个线程中的功能合并为单个线程来删除左侧的任何线程？如果可以，请执行此操作。相反，您是否需要将任何线程拆分为2个或更多线程以分离功能？如果可以，请执行此操作
评估正确性：您能否将右侧的任何资源合并为1，以使用单个互斥锁进行保护？例如：尝试将“UART写入”和“UART读取”合并为单个受保护的资源。这是否有效？好吧，如果“只读线程”和“只读线程”必须分别在完全相同的时间并行读写（即：他们不能互相等待并以串行方式进行操作），那么不行！这不起作用！他们必须保持独立的资源！但是如果他们可以根据您的项目和设计，互相等待并以串行方式进行这些操作，那么是的！您可以将这两件事结合起来，现在使用一个互斥锁来保护他们，并删除多余的互斥锁
一旦您评估了左侧和右侧，根据设计需要组合或拆分线程和资源，请重复上述步骤3和4。计算圆圈数。这就是您有多少竞争条件，以及您的设计需要多少不同的互斥体
注意你在这里有多大的回旋余地和控制权。这在很大程度上取决于你的具体架构设计。你是架构师和设计师。你可能会提出不同的解决方案和互斥锁的数量，每种设计都有利弊。这可能很好。保持最小值d：你是设计师，设计可能会有所不同。有时没有完美的设计，你只需要做出权衡。尽管如此，上述有条理的过程将帮助你确定具体设计需要多少互斥锁。
：这取决于你有多少竞争条件。这里有一些更详细的信息来确定这一点

拿出一张纸。在右边，列出页面上所有受保护的资源，您希望在使用时保证任何线程以独占方式访问这些资源
在页面的左侧，列出页面上可能需要这些资源的所有线程。如果您只知道它将是>1个线程，您可以只写“线程1”和“线程2”来表示无限多的线程

从左边的每个线程到右边它需要的所有资源绘制一个箭头
圈出右侧有多个箭头指向单个资源的所有箭头交叉点。计算圆圈的数量。这就是此模块的竞争条件，这就是您需要的独立互斥量
我刚刚起草了一个例子。这个例子有3个竞争条件（注意3个圆圈），因此需要3个单独的互斥锁：


现在评估左侧：您是否可以通过将多个线程中的功能合并为单个线程来删除左侧的任何线程？如果可以，请执行此操作。相反，您是否需要将任何线程拆分为2个或更多线程以分离功能？如果可以，请执行此操作
评估右侧：您可以将右侧的任何资源合并为1，并通过单个静音进行保护吗