Question

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

与“线程本地存储”相关的程序之一，我在下面复制供您参考。它看起来很简单，就像2个线程一样，都增加了类数据成员'm1'，'m2'，'m3'。在这个例子中，'m2'是一个静态类变量，可以被两个线程访问。

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

但不，m2的打印看起来根本没有关键部分。 'm2'值使用以下值进行加扰：

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

我一定错过了一些基本的东西。它是什么？

任何人都有帮助吗？

下面的代码是来自网页的微小值更改，可以在VStuio中轻松编译。

#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的所有实例都将使用的ThreadX。理想情况下，这将是InitializeCriticalSection中的static member variable。但是，C++ doesn't have static constructors（与C＃一样），因此您必须以其他方式拨打main()。您可以随时将其设置为在{{1}}初始化的静态变量。

Answer 2

m_CriticalSection成员对于ThreadX类的每个实例都是不同的。因此，每个ThreadX对象都使用自己的关键部分 - 这就是为什么它不会相互影响的原因。

Answer 3

这是因为您为每个线程定义了一个关键部分。您需要在main中定义一个全局关键部分，并将该关键部分传递给每个线程类。

多线程中的关键部分用法？

3 个答案: