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