Multithread 之 synchronous

• Critical Sections（临界区）：用来实现“排他性占用”。适用范围是单一进程的各线程之间。
• 一个局部对象，不是一个核心对象
• 快速而有效率
• 不能同时有一个以上的Critical Section被等待
• 无法侦测是否已被某个线程放弃
• 例子：

    #include <windows.h>
  
  
  
    #include <process.h>
  
  
  
    #include <stdio.h>
  
  
  
    
  
    CRITICAL_SECTION cs;
  
    int a[ 5 ];
  
    
  
    void Thread( void* pParams )
  
    {
  
      int i, num = 0;
  
    
  
      while ( TRUE )
  
      {
  
         EnterCriticalSection( &cs );
  
         for ( i = 0; i < 5; i++ ) a[ i ] = num;
  
         LeaveCriticalSection( &cs );
  
         num++;
  
      }
  
    }
  
    
  
    int main( void )
  
  
  
    { 
  
      InitializeCriticalSection( &cs );
  
      _beginthread( Thread, 0, NULL );
  
    
  
      while( TRUE )
  
      {
  
         EnterCriticalSection( &cs );
  
         printf( "%d %d %d %d %d\n", 
  
                 a[ 0 ], a[ 1 ], a[ 2 ],
  
                 a[ 3 ], a[ 4 ] );
  
         LeaveCriticalSection( &cs );
  
      }
  
      return 0;
  
    }
  
  

• Mutexes（互斥器）：是一个核心对象，可以在不同的线程之间实现“排他性占用”，甚至即使那些线程分属不同进程
• 一个核心对象
• 如果拥有mutex的那个线程结束，则会产生一个“abandoned”错误信息
• 可以使用Wait...()等待一个mutex
• 可以指定名称，因此可以被其他进程开启
• 只能被拥有它的那个线程释放
• 例子：

    #include <windows.h>
  
  
  
    #include <process.h>
  
  
  
    #include <stdio.h>
  
  
  
    
  
    HANDLE hMutex;
  
    int a[ 5 ];
  
    
  
    void Thread( void* pParams )
  
    { 
  
       int i, num = 0;
  
    
  
       while ( TRUE )
  
       { 
  
          WaitForSingleObject( hMutex, INFINITE );
  
          for ( i = 0; i < 5; i++ ) a[ i ] = num;
  
          ReleaseMutex( hMutex );
  
          num++;
  
       }
  
    }
  
    
  
    int main( void )
  
    {
  
       hMutex = CreateMutex( NULL, FALSE, NULL );
  
       _beginthread( Thread, 0, NULL );
  
    
  
       while( TRUE )
  
  
  
       {
  
          WaitForSingleObject( hMutex, INFINITE );
  
          printf( "%d %d %d %d %d\n", 
  
                  a[ 0 ], a[ 1 ], a[ 2 ],
  
                  a[ 3 ], a[ 4 ] );
  
          ReleaseMutex( hMutex );
  
       }
  
       return 0;
  
    }
  
  

• Semaphores（信号量）：被用来追踪有限的资源
• 一个核心对象
• 没有拥有者
• 可以指定名称，因此可以被其他进程开启
• 可被任一线程释放
• 例子：
• Event Objects（事件）：通常适用于overlapped I/O，或用来设计某些自定义的同步对象
• 一个核心对象
• 完全在程序掌控之下
• 适用于设计新的同步对象
• “要求苏醒”的请求不会被储存起来，可能会遗失掉
• 可以指定名称，因此可以被其他进程开启
• 例子：

    #include <windows.h>
  
  
  
    #include <process.h>
  
  
  
    #include <stdio.h>
  
  
  
    
  
    HANDLE hEvent1, hEvent2;
  
    int a[ 5 ];
  
    
  
    void Thread( void* pParams )
  
    {
  
       int i, num = 0;
  
  
  
       while ( TRUE )
  
       {
  
          WaitForSingleObject( hEvent2, INFINITE );
  
          for ( i = 0; i < 5; i++ ) a[ i ] = num;
  
          SetEvent( hEvent1 );
  
          num++;
  
       }
  
    }
  
    
  
    int main( void )
  
    {
  
       hEvent1 = CreateEvent( NULL, FALSE, TRUE, NULL );
  
       hEvent2 = CreateEvent( NULL, FALSE, FALSE, NULL );
  
    
  
       _beginthread( Thread, 0, NULL );
  
    
  
       while( TRUE )
  
       { 
  
          WaitForSingleObject( hEvent1, INFINITE );
  
          printf( "%d %d %d %d %d\n", 
  
                  a[ 0 ], a[ 1 ], a[ 2 ],
  
                  a[ 3 ], a[ 4 ] );
  
          SetEvent( hEvent2 );
  
       }
  
       return 0;
  
    }
  
  

• 
• 参考：
• 《Win32多线程程序设计》
• http://www.codeproject.com/KB/threads/sync.aspx