c++ - 同步线程 - InterlockedExchange

Question

我喜欢检查线程是否在工作。如果线程正在工作，我将等待一个事件，直到线程停止工作。线程将在最后设置的事件。

为了检查线程是否正常工作，我声明了一个 volatile bool 变量。如果线程正在运行，bool 变量将为 true，否则为 false。在线程结束时，bool 变量将被设置为 false。

使用 volatile bool 变量是否足够，还是必须使用原子函数？

顺便说一句:有人可以向我解释一下 InterlockedExchange 方法吗，我不明白我需要这个功能的用例。

更新

我发现如果没有我的代码，就不清楚 volatile bool 变量是否足够。我写了一个测试类来显示我的问题。

class Testclass
{
public:
    Testclass(void);
    ~Testclass(void);

    void doThreadedWork();
    void Work();

    void StartWork();

    void WaitUntilFinish();
private:
    HANDLE hHasWork;
    HANDLE hAbort;
    HANDLE hFinished;

    volatile bool m_bWorking;
};

//.cpp

#include "stdafx.h"
#include "Testclass.h"

CRITICAL_SECTION cs;

DWORD WINAPI myThread(LPVOID lpParameter)
{
    Testclass* pTestclass = (Testclass*) lpParameter;
    pTestclass->doThreadedWork();
    return 0;
}

Testclass::Testclass(void)
{
    InitializeCriticalSection(&cs);
    DWORD myThreadID;
    HANDLE myHandle = CreateThread(0, 0, myThread, this, 0, &myThreadID);
    m_bWorking = false;

    hHasWork = CreateEvent(NULL,TRUE,FALSE,NULL);
    hAbort = CreateEvent(NULL,TRUE,FALSE,NULL);

    hFinished = CreateEvent(NULL,FALSE,FALSE,NULL);
}


Testclass::~Testclass(void)
{
    DeleteCriticalSection(&cs);

    CloseHandle(hHasWork);
    CloseHandle(hAbort);
    CloseHandle(hFinished);
}

void Testclass::Work()
{
    // do some work

    m_bWorking = false;
    SetEvent(hFinished);
}

void Testclass::StartWork()
{
    EnterCriticalSection(&cs);
    m_bWorking = true;
    ResetEvent(hFinished);
    SetEvent(hHasWork);
    LeaveCriticalSection(&cs);
}

void Testclass::doThreadedWork()
{
    HANDLE hEvents[2];
    hEvents[0] = hHasWork;
    hEvents[1] = hAbort;

    while(true)
    {
        DWORD dwEvent = WaitForMultipleObjects(2, hEvents, FALSE, INFINITE); 
        if(WAIT_OBJECT_0 == dwEvent)
        {
            Work();
        }
        else
        {
            break;
        }
    }
}


void Testclass::WaitUntilFinish()
{
    EnterCriticalSection(&cs);
    if(!m_bWorking)
    {
        // if the thread is not working, do not wait and return
        LeaveCriticalSection(&cs);
        return;
    }

    WaitForSingleObject(hFinished,INFINITE);

    LeaveCriticalSection(&cs);
}

对我来说，m_bWorking 值是否以原子方式或者 volatile 转换是否足够就不是很清楚。

Answer 1

您的问题涉及很多背景知识。例如，我们不知道您使用的是什么工具链，所以我将把它作为一个 winapi 问题来回答。我进一步假设您有这样的想法:

volatile bool flag = false;

DWORD WINAPI WorkFn(void*) {
   flag = true;
   //  work here
   ....
   // done.
   flag = false;
   return 0;
}

int main() {
  HANDLE th = CreateThread(...., &WorkFn, NULL, ..);

  // wait for start of work.
  while (!flag) {
     // ?? # 1
  }
  // Seems thread is busy now. Time to wait for it to finish.
  while (flag) {
     // ?? # 2
  }

}

这里有很多错误。对于初学者 volatile在这里做的很少。当flag = true碰巧它最终对另一个线程可见，因为它由全局变量支持。之所以如此，是因为它至少会进入缓存，并且缓存有办法告诉其他处理器给定的行(地址范围)是脏的。它不会进入缓存的唯一方法是，如果编译器进行 super 疯狂的优化，其中 flag作为寄存器留在 cpu 中。这实际上可能会发生，但不会发生在这个特定的代码示例中。

因此 volatile 告诉编译器永远不要将变量保留为寄存器。就是这样，每次您看到一个 volatile 变量时，您都可以将其翻译为“永远不要注册此变量”。它在这里的使用基本上只是一种偏执的举动。

如果这段代码是您所想的，那么这种循环标志模式就称为 Spinlock而这个真的很差。在用户模式程序中，这几乎从来都不是正确的做法。

在我们探讨更好的方法之前，让我来解决您的 Interlocked 问题。人们通常的意思是这种模式

volatile long flag = 0;

DWORD WINAPI WorkFn(void*) {
  InterlockedExchange(&flag, 1);
  ....
}

int main() {
 ...
  while (InterlockedCompareExchange(&flag, 1, 1) = 0L) {
    YieldProcessor();
  }
  ...
}

假设 ...表示与以前类似的代码。什么InterlockedExchange()正在做的是强制写入内存以一种确定性的方式发生，“现在广播更改”，一种方式和以相同的“绕过缓存”方式读取它的典型方式是通过InterlockedCompareExchange() .

它们的一个问题是它们会在系统总线上产生更多的流量。也就是说，总线现在用于在系统上的 cpu 之间广播缓存同步数据包。

std::atomic<bool> flag将是现代的 C++11 方法来做同样的事情，但仍然不是您真正想要做的。

我添加了 YieldProcessor()调用那里指出真正的问题。当您等待内存地址更改时，您正在使用 cpu 资源，这些资源可以更好地用于其他地方，例如在实际工作中 (!!)。如果您实际上放弃了处理器，操作系统至少有可能将其提供给 WorkFn。 ，但在多核机器中，它会很快返回到轮询变量。在现代机器中，您将检查此 flag每秒百万次，以产量计算，大概每秒20万次。无论哪种方式都是可怕的浪费。

你想在这里做的是利用 Windows 进行零成本等待，或者至少是你想要的低成本:

DWORD WINAPI WorkFn(void*) {
   //  work here
   ....
   return 0;
}

int main() {
  HANDLE th = CreateThread(...., &WorkFn, NULL, ..);

  WaitForSingleObject(th, INFINITE);
  // work is done!
  CloseHandle(th);

}

当您从工作线程返回时，线程句柄会收到信号并等待它得到满足。卡在 WaitForSingleObject你不消耗任何 cpu 周期。如果您想在等待时在 main() 函数中执行周期性事件，您可以替换 INFINITE 1000，每秒释放一次主线程。在这种情况下，您需要检查 WaitForSingleObject 的返回值从线程完成情况中判断超时。

如果您需要真正知道工作何时开始，您需要一个额外的可等待对象，例如，通过CreateEvent() 获取的Windows 事件。可以等待使用相同的 WaitForSingleObject .

更新 [1/23/2016]

现在我们可以看到您想要的代码，您不需要原子，volatile工作得很好。 m_bWorking true 无论如何都受到 cs 互斥锁的保护案例。

如果我建议，您可以使用 TryEnterCriticalSection和 cs 在没有 m_bWorking 的情况下完成同样的事情完全:

void Testclass::Work()
{
    EnterCriticalSection(&cs);
    // do some work

    LeaveCriticalSection(&cs);
    SetEvent(hFinished);     // could be removed as well
}

void Testclass::StartWork()
{
    ResetEvent(hFinished);      // could be removed.
    SetEvent(hHasWork);
}

void Testclass::WaitUntilFinish()
{
    if (TryEnterCriticalSection(&cs)) {
        // Not busy now.
        LeaveCriticalSection(&cs);
        return;
    } else {
        // busy doing work. If we use EnterCriticalSection(&cs)
        // here we can even eliminate hFinished from the code.
    }
  ...
}