c++多线程3

一 Critical Sections

1） 因为Critical Sections不是内核对象，所以只能用来统一进程内线程间的同步，不能用来多个不同进程间的线程的同步。

2） 如果在Critical Sections中间突然程序crash或是exit而没有调用LeaveCriticalSection，则结果是改线程所对应的内核不能被释放，该线程成为死线程。

3） 要比其他的内核对象的速度要快。

二 使用CriticalSections的简单实例，Stack在push的时候可以分为3个步骤，看下面的代码，但是如果在第2步后此线程中断切换到其他的线程，其他的线程push后再返回执行时，此线程继续执行，这样有可能刚才其他线程push就会被覆盖了，在stack里找不到了。（下面的代码在debug下使用了CriticalSection，release下可能有问题）

// beginthread.cpp : Defines the entry point for the console application.

//

#include "stdafx.h"
#include "beginthread.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

// testth.cpp : Defines the entry point for the console application.

#include <windows.h>
#include <process.h>
#include <stdio.h>
using namespace std;
//stack:
struct Node 
{
  struct Node *next; 
  int data; 
}; 
struct Stack 
{ 
  struct Node *head; 
#ifdef _DEBUG
  CRITICAL_SECTION critical_sec; 
#endif

  Stack()
  {
  head = NULL;
#ifdef _DEBUG
  InitializeCriticalSection(&critical_sec);
#endif
  }
  ~Stack()
  {  
  if(head != NULL)  
  {
  if(NULL == head->next)
  {  
  delete head;
  head = NULL;
  }
  else
  {
  Node *p = head;
  Node *q = head->next;

  while(q != NULL)
  {  
  delete p;
  p = q;
  q = q->next;
  };  
  delete p;
  p = NULL;
  }  
  }
#ifdef _DEBUG
  DeleteCriticalSection(&critical_sec);
#endif
  }
  void Push (int num) 
  { 
  //enter critical section, add a new node and then  
#ifdef _DEBUG
  EnterCriticalSection (&critical_sec);
#endif
  Node * node = new Node();
  node->next = head;
  node->data = num;
  head = node;  
  printf("Stack:%d/n",num);
  //leave critical section 
#ifdef _DEBUG
  LeaveCriticalSection (&critical_sec);
#endif
  } 
  int Pop () 
  { 
#ifdef _DEBUG
  EnterCriticalSection (&critical_sec);
#endif
  int result = 0;
  if(head!= NULL)
  {
  result = head->data;
  if(head->next != NULL)
  {
  Node *temp = head->next; 
  delete head;
  head = temp;
  }
  else
  head = NULL;
  }  
#ifdef _DEBUG
  LeaveCriticalSection (&critical_sec); 
#endif
  return result; 
  }
};

//test:
unsigned __stdcall Thread1(void * pVoid)
{
  Stack *stack = ((Stack*)pVoid);
  for(int i = 200; i<220;++i)
  {
  stack->Push(i);
  }
  return 1;  
}
unsigned __stdcall Thread2(void *pVoid)
{
  Stack *stack = ((Stack*)pVoid);
  for(int i = 0; i<20; ++i)
  {
  stack->Push(i);  
  }
  return 1;
}


int main()
{ 
  Stack stack;
  stack.Push(1000);
  stack.Push(1000);

  HANDLE hth1;
  unsigned uiThread1ID;

  hth1 = (HANDLE)_beginthreadex( NULL, // security
  0, // stack size
  Thread1,
  (void*)&stack, // arg list
  CREATE_SUSPENDED, // so we can later call ResumeThread()
  &uiThread1ID );

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

  DWORD dwExitCode;

  GetExitCodeThread( hth1, &dwExitCode ); // should be STILL_ACTIVE = 0x00000103 = 259
  printf( "initial thread 1 exit code = %u/n", dwExitCode );

  HANDLE hth2;
  unsigned uiThread2ID;

  hth2 = (HANDLE)_beginthreadex( NULL, // security
  0, // stack size
  Thread2,
  (void*)&stack, // arg list
  CREATE_SUSPENDED, // so we can later call ResumeThread()
  &uiThread2ID );

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

  GetExitCodeThread( hth2, &dwExitCode ); // should be STILL_ACTIVE = 0x00000103 = 259
  printf( "initial thread 2 exit code = %u/n", dwExitCode );  

  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 );

  CloseHandle( hth1 );
  CloseHandle( hth2 );  

  printf("Primary thread terminating./n");

 return 0;
}
// beginthread.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include "beginthread.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

// testth.cpp : Defines the entry point for the console application.
#include <iostream>
#include <windows.h>
#include <process.h>
#include <stdio.h>
using namespace std;

class CritSect
{
public:
  friend class Lock;
  CritSect() { InitializeCriticalSection(&_critSection); }
  ~CritSect() { DeleteCriticalSection(&_critSection); }
private:
  void Acquire(){EnterCriticalSection(&_critSection);}
  void Release(){LeaveCriticalSection(&_critSection);}

  CRITICAL_SECTION _critSection;
};

class Lock
{
public:
  Lock(CritSect& critSect):_critSect(critSect) { _critSect.Acquire(); }
  ~Lock(){_critSect.Release();}
private:
  CritSect& _critSect;
};

// MT-exclusive lock
class CLock {
public:
  CLock() { InitializeCriticalSection (&m_criticalSection); }
  void Lock () { EnterCriticalSection (&m_criticalSection); }
  void Unlock () { LeaveCriticalSection (&m_criticalSection); }
  virtual ~CLock() { DeleteCriticalSection (&m_criticalSection); }
private:
  CRITICAL_SECTION m_criticalSection;
};


// Scoped MT-exclusive lock
class CScopedLocker {
public:
  CScopedLocker (CLock * t) : m_lock (t) { m_lock->Lock(); }
  ~CScopedLocker() { m_lock->Unlock(); }
private:
  CLock * m_lock;
};

static int g_n;
CritSect sect;

Thread One Function///
UINT ThreadOne(LPVOID lParam)
{
  Lock lock(sect);  
  //CScopedLocker st(&t);
   
  for(int i=0;i<100;i++)
  {
  g_n++;
  cout << "Thread 1: " << g_n << "/n";
  }  
  // return the thread
  return 0;
}


Thread Two Function///
UINT ThreadTwo(LPVOID lParam)
{
  Lock lock(sect);
  //CScopedLocker st(&t);

  for(int i=300;i<400;i++)
  {
  g_n++;
  cout << "Thread 2: "<< g_n << "/n";
  }

  // return the thread
  return 0;
}

int main()
{

  // Create the array of Handle
  HANDLE hThrd[2];  
  //Thread ID's
  DWORD IDThread1, IDThread2;

  // Create thredas use CreateThread function with NULL Security
  hThrd[0] = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE) ThreadOne,(LPVOID)NULL,0,&IDThread1);  
  hThrd[1] = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE) ThreadTwo,(LPVOID)NULL,0,&IDThread2); 

  // Wait for the main thread 
  WaitForMultipleObjects(2,hThrd,TRUE,INFINITE);
   
  return 0;
}