C++ C++；确保线程按特定顺序更改公共资源

这是我们的后续报道。我试图确保公共资源（m_pCurrentWorker）由多个线程按一定顺序更改。我在每个线程中使用互斥和条件变量，在线程执行结束时，我会通知下一个线程的条件变量以继续。工作代码如下，我运行了几十次，始终得到正确的执行顺序，似乎没有死锁：

entered thread 0
leaving thread 0
entered thread 1
leaving thread 1
entered thread 2
leaving thread 2

然而，在最初的问题下面有一个讨论，即这种实现是错误的。很高兴听到其他人对这个设计的意见和改进建议

#include "stdafx.h"
#include <iostream>
#include <thread>
#include <mutex>
#include <chrono>
#include <condition_variable> 

std::mutex* m_pMutexs;
std::condition_variable* m_pCVs;
int m_pCurrentWorker;

void func(int i)
{
    std::mutex* pCurMutex = &m_pMutexs[i];

    std::condition_variable* pCuCV = &m_pCVs[i];

    std::unique_lock<std::mutex> lk(m_pMutexs[i]);

    while (i != m_pCurrentWorker)
    {
        pCuCV->wait(lk);
    }

    std::cout << "entered thread " << i << std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(rand() % 2));
    std::cout << "leaving thread " << i << std::endl;

    m_pCurrentWorker++;
    lk.unlock();
    if (m_pCurrentWorker > 2)
    {
        return;
    }
    pCuCV = &m_pCVs[m_pCurrentWorker];
    pCuCV->notify_one();

}

int _tmain(int argc, _TCHAR* argv[])
{
    m_pMutexs = new std::mutex[3];

    m_pCVs = new std::condition_variable[3];

    m_pCurrentWorker = 0;

    srand((unsigned int)time(0));

    std::thread t1(func, 0);
    std::thread t2(func, 1);
    std::thread t3(func, 2);

    t1.join();
    t2.join();
    t3.join();

    return 0;
}

#包括“stdafx.h”
#包括
#包括
#包括
#包括
#包括
std:：mutex*m_pmutex；
std:：条件变量*m\U PCV；
国际工人协会；
无效函数（整数i）
{
std:：mutex*pCurMutex=&m_pMutexs[i]；
std:：条件变量*pCuCV=&m_pCVs[i]；
std:：unique_lock lk（m_pMutexs[i]）；
而（i！=m_pCurrentWorker）
{
pCuCV->等待（lk）；
}
std：：你可能会比at得到更好的结果吗？正如你在上一个问题的评论中指出的，你试图实现的目标完全违背了拥有多个线程的观点。@mattnewport有一个非常好的观点。你考虑过使用状态机吗？我不同意。假设线程并行工作，然后在e执行的中间/结尾每个线程都需要确保前一个线程完成并更改了公共资源。在单个线程中运行此逻辑的速度要慢得多。如果您有多个独立的昂贵工作，每个工作都会产生一个便宜的结果，然后必须使用该结果修改特定线程中的某些共享状态顺序，那么为什么不让一个主线程等待所有昂贵操作的结果，然后按顺序应用状态更改呢？正如在对上一个问题的评论中所指出的，您可能会在上一个问题上得到更好的结果，您试图实现的目标完全违背了拥有多个线程的意义。@mattnewport有一个v非常好的一点。你考虑过状态机吗？我不同意。假设线程并行地做一些工作，然后在执行的中间/结尾，每个线程需要确保前一个线程完成并更改了公共资源。在单个线程中运行此逻辑要慢得多。如果你有多个线程的情况一个独立的昂贵的工作，每个工作都会产生一个廉价的结果，然后必须使用该结果以特定的顺序修改某些共享状态，那么为什么不让一个主线程等待所有昂贵操作的结果，然后依次应用状态更改呢？