c++ - 多线程中的临界区用法？

Question

我在网上找到了这个关于多线程的教程，并下载了代码以在 visual studio 2010 上试用。http://www.codeproject.com/Articles/14746/Multithreading-Tutorial

我在下面复制了一个与'Thread Local Storage'相关的程序，供您引用。它看起来很简单，只有 2 个线程，都在增加类数据成员 'm1'、'm2'、'm3'。在这个例子中，'m2' 是一个静态类变量，可以被两个线程访问。

请注意，在代码中，关键部分在文件开头使用“#define WITH_SYNCHRONIZATION”启用。我的理解是，由于 'TMain()' 中的 'for 循环' 受临界区保护，无论哪个线程首先到达 'TMain()' 都将作为一个整体完成 50,000 增量，而不会与其他线程交错，打印输出 '50,020 for m2'，另一个线程将继续其余部分并稍后打印出 '100,020 for m2'。

但是不，m2 的打印结果看起来根本没有临界区。 'm2' 值被以下值打乱:

线程 t2:... m2=50376 ...
线程 t1: ... m2=63964 ...

我一定是漏掉了一些基本的东西。这是什么？

以下代码取自网页，数值略有改动，可直接在VStudio中编译。

#include <stdio.h>
#include <windows.h>
#include <process.h>
#include <string>

using namespace std;

#define WITH_SYNCHRONIZATION

class ThreadX
{
private:
  int        m1;
  static int m2;                       // shared variable
  static  __declspec(thread)  int m3;  // thread local variable


#ifdef WITH_SYNCHRONIZATION
  CRITICAL_SECTION m_CriticalSection; 
#endif

public:
  string threadName;

  ThreadX()
  {
      m1 = 10;
#ifdef WITH_SYNCHRONIZATION
        InitializeCriticalSection(&m_CriticalSection);
#endif
  }

  virtual ~ThreadX()
  {
#ifdef WITH_SYNCHRONIZATION
       // Release resources used by the critical section object.
       DeleteCriticalSection(&m_CriticalSection);
#endif
  }

  void TMain(void) 
  {
#ifdef WITH_SYNCHRONIZATION
    EnterCriticalSection( &m_CriticalSection );
#endif

    for ( int i = 1; i <= 50000; i++ )
    {
        ++m1;  // init value 10
        ++m2;  // init value 20
        ++m3;  // init value 30
    }

    printf( "Thread %s: m1 = %d, m2 = %d, m3 = %d\n", threadName.c_str(), m1, m2, m3 );

#ifdef WITH_SYNCHRONIZATION
    LeaveCriticalSection( &m_CriticalSection );
#endif

  } 

  static unsigned __stdcall ThreadStaticTMain(void * pThis)
  {
      ThreadX * pthX = (ThreadX*)pThis;
      pthX->TMain();

      return 1;
  }

};

int ThreadX::m2 = 20;
int ThreadX::m3 = 30;

int main()
{
    // In this program we create 2 threads and request that their
    // entry-point-function be the TMain() function of the ThreadX
    // class.  Because _beginthreadex() cannot accept a class member
    // function we must employ a 2 step process involving a tricky
    // cast to accomplish this.

    ThreadX * o1 = new ThreadX();

    HANDLE   hth1;
    unsigned  uiThread1ID;

    hth1 = (HANDLE)_beginthreadex( NULL,         
                                   0,            
                                   ThreadX::ThreadStaticTMain,
                                   o1,           
                                   CREATE_SUSPENDED, 
                                   &uiThread1ID );

    if ( hth1 == 0 )
        printf("Failed to create thread 1\n");

    DWORD   dwExitCode;

    GetExitCodeThread( hth1, &dwExitCode );
    printf( "initial thread 1 exit code = %u\n", dwExitCode );

    o1->threadName = "t1";

    ThreadX * o2 = new ThreadX();

    HANDLE   hth2;
    unsigned  uiThread2ID;

    hth2 = (HANDLE)_beginthreadex( NULL,         
                                   0,            
                                   ThreadX::ThreadStaticTMain,
                                   o2,           
                                   CREATE_SUSPENDED, 
                                   &uiThread2ID );

    if ( hth2 == 0 )
        printf("Failed to create thread 2\n");

    GetExitCodeThread( hth2, &dwExitCode ); 
    printf( "initial thread 2 exit code = %u\n", dwExitCode );

    o2->threadName = "t2";

    ResumeThread( hth1 );   
    ResumeThread( hth2 );   

    WaitForSingleObject( hth1, INFINITE );  
    WaitForSingleObject( hth2, INFINITE );  

    GetExitCodeThread( hth1, &dwExitCode );
    printf( "thread 1 exited with code %u\n", dwExitCode );

    GetExitCodeThread( hth2, &dwExitCode );
    printf( "thread 2 exited with code %u\n", dwExitCode );

    // The handle returned by _beginthreadex() has to be closed
    // by the caller of _beginthreadex().

    CloseHandle( hth1 );
    CloseHandle( hth2 );

    delete o1;
    o1 = NULL;

    delete o2;
    o2 = NULL;

    printf("Primary thread terminating.\n");
    return 0;
}

Answer 1

CRITICAL_SECTION m_CriticalSection; 是您的 ThreadX 类中的成员(实例)变量。这意味着每次您创建 ThreadX 的实例(您创建了两次)，您都在创建一个新的 CRITICAL_SECTION。这没有好处，因为每个实例都会进入自己的临界区，没问题，然后继续破坏您试图保护的变量。

如果您查看 EnterCriticalSection 的文档，您会看到它提到只创建一个 CRITICAL_SECTION，每个线程都会尝试进入。

相反，您只需要创建一个 CRITICAL_SECTION，ThreadX 的所有实例都将使用它。理想情况下，这将是 static member variable在 ThreadX 中。然而，C++ doesn't have static constructors (如 C#)，因此您必须以其他方式调用 InitializeCriticalSection。您始终可以将其设为在 main() 中初始化的静态变量。