MFC多线程与线程同步 （三）

3.信号量内核对象

　　信号量（Semaphore）内核对象对线程的同步方式与前面几种方法不同，它允许多个线程在同一时刻访问同一资源，但是需要限制在同一时刻访问此资源的最大线程数目。在用CreateSemaphore（）创建信号量时即要同时指出允许的最大资源计数和当前可用资源计数。一般是将当前可用资源计数设置为最大资源计数，每增加一个线程对共享资源的访问，当前可用资源计数就会减1，只要当前可用资源计数是大于0的，就可以发出信号量信号。但是当前可用计数减小到0时则说明当前占用资源的线程数已经达到了所允许的最大数目，不能在允许其他线程的进入，此时的信号量信号将无法发出。线程在处理完共享资源后，应在离开的同时通过ReleaseSemaphore（）函数将当前可用资源计数加1。在任何时候当前可用资源计数决不可能大于最大资源计数。
　　使用信号量内核对象进行线程同步主要会用到CreateSemaphore（）、OpenSemaphore（）、ReleaseSemaphore（）、WaitForSingleObject（）和WaitForMultipleObjects（）等函数。其中，CreateSemaphore（）用来创建一个信号量内核对象，其函数原型为：

HANDLE CreateSemaphore(
　LPSECURITY_ATTRIBUTES lpSemaphoreAttributes,  //  安全属性指针
　LONG lInitialCount, 　　　　　　　　　　　　　　 //  初始计数
　LONG lMaximumCount, 　　　　　　　　　　　　　　 //  最大计数
　LPCTSTR lpName 　　　　　　　　　　　　　　　　　 //  对象名指针
);  

　　参数lMaximumCount是一个有符号32位值，定义了允许的最大资源计数，最大取值不能超过4294967295。lpName参数可以为创建的信号量定义一个名字，由于其创建的是一个内核对象，因此在其他进程中可以通过该名字而得到此信号量。OpenSemaphore（）函数即可用来根据信号量名打开在其他进程中创建的信号量，函数原型如下：

HANDLE OpenSemaphore(
　DWORD dwDesiredAccess, 　　 //  访问标志
　BOOL bInheritHandle, 　　　 //  继承标志
　LPCTSTR lpName 　　　　　　 //  信号量名
); 
在线程离开对共享资源的处理时，必须通过ReleaseSemaphore（）来增加当前可用资源计数。否则将会出现当前正在处理共享资源的实际线程数并没有达到要限制的数值，而其他线程却因为当前可用资源计数为0而仍无法进入的情况。ReleaseSemaphore（）的函数原型为：

BOOL ReleaseSemaphore(
　HANDLE hSemaphore,  　　 //  信号量句柄
　LONG lReleaseCount,  　　//  计数递增数量
　LPLONG lpPreviousCount  //  先前计数
);

　该函数将lReleaseCount中的值添加给信号量的当前资源计数，一般将lReleaseCount设置为1，如果需要也可以设置其他的值。WaitForSingleObject（）和WaitForMultipleObjects（）主要用在试图进入共享资源的线程函数入口处，主要用来判断信号量的当前可用资源计数是否允许本线程的进入。只有在当前可用资源计数值大于0时，被监视的信号量内核对象才会得到通知。
　　信号量的使用特点使其更适用于对Socket（套接字）程序中线程的同步。例如，网络上的HTTP服务器要对同一时间内访问同一页面的用户数加以限制，这时可以为没一个用户对服务器的页面请求设置一个线程，而页面则是待保护的共享资源，通过使用信号量对线程的同步作用可以确保在任一时刻无论有多少用户对某一页面进行访问，只有不大于设定的最大用户数目的线程能够进行访问，而其他的访问企图则被挂起，只有在有用户退出对此页面的访问后才有可能进入。下面给出的示例代码即展示了类似的处理过程：
HANDLE hSemaphore;　　　　　　　　　　　　　　　　 //  信号量对象句柄

UINT ThreadProc15(LPVOID pParam)
{ 
　WaitForSingleObject(hSemaphore, INFINITE);　　 //  试图进入信号量关口
　
　AfxMessageBox( " 线程一正在执行! " );　　　　　　　　 //  线程任务处理
　
　ReleaseSemaphore(hSemaphore,  1 , NULL);　　　　 //  释放信号量计数
　 return   0 ;
}
UINT ThreadProc16(LPVOID pParam)
{ 

　WaitForSingleObject(hSemaphore, INFINITE);

　AfxMessageBox( " 线程二正在执行! " );

　ReleaseSemaphore(hSemaphore,  1 , NULL);
　 return   0 ;
}
UINT ThreadProc17(LPVOID pParam)
{ 

　WaitForSingleObject(hSemaphore, INFINITE);

　AfxMessageBox( " 线程三正在执行! " );

　ReleaseSemaphore(hSemaphore,  1 , NULL);
　 return   0 ;
}
……
void  CSample08View::OnSemaphore() 
{
　hSemaphore  =  CreateSemaphore(NULL,  2 ,  2 , NULL);　　 //  创建信号量对象

　AfxBeginThread(ThreadProc15, NULL);　　　　　　　　　 //  开启线程
　AfxBeginThread(ThreadProc16, NULL);
　AfxBeginThread(ThreadProc17, NULL);
}

在MFC中，通过CSemaphore类对信号量作了表述。该类只具有一个构造函数，可以构造一个信号量对象，并对初始资源计数、最大资源计数、对象名和安全属性等进行初始化，其原型如下：

 　　CSemaphore( LONG lInitialCount = 1, LONG lMaxCount = 1, LPCTSTR pstrName = NULL, LPSECURITY_ATTRIBUTES lpsaAttributes = NULL );

　　在构造了CSemaphore类对象后，任何一个访问受保护共享资源的线程都必须通过CSemaphore从父类CSyncObject类继承得到的Lock（）和UnLock（）成员函数来访问或释放CSemaphore对象。与前面介绍的几种通过MFC类保持线程同步的方法类似，通过CSemaphore类也可以将前面的线程同步代码进行改写，这两种使用信号量的线程同步方法无论是在实现原理上还是从实现结果上都是完全一致的。下面给出经MFC改写后的信号量线程同步代码：

//  MFC信号量类对象
CSemaphore g_clsSemaphore( 2 ,  2 );
UINT ThreadProc24(LPVOID pParam)
{ 
　 //  试图进入信号量关口
　g_clsSemaphore.Lock();
　 //  线程任务处理
　AfxMessageBox( " 线程一正在执行! " );
　 //  释放信号量计数
　g_clsSemaphore.Unlock();
　 return   0 ;
}
UINT ThreadProc25(LPVOID pParam)
{
　 //  试图进入信号量关口
　g_clsSemaphore.Lock();
　 //  线程任务处理
　AfxMessageBox( " 线程二正在执行! " );
　 //  释放信号量计数
　g_clsSemaphore.Unlock();
　 return   0 ;
}
UINT ThreadProc26(LPVOID pParam)
{
　 //  试图进入信号量关口
　g_clsSemaphore.Lock();
　 //  线程任务处理
　AfxMessageBox( " 线程三正在执行! " );
　 //  释放信号量计数
　g_clsSemaphore.Unlock();
　 return   0 ;
}
……
void  CSample08View::OnSemaphoreMfc() 
{
　 //  开启线程
　AfxBeginThread(ThreadProc24, NULL);
　AfxBeginThread(ThreadProc25, NULL);
　AfxBeginThread(ThreadProc26, NULL);
}

4.互斥内核对象

     互斥（Mutex）是一种用途非常广泛的内核对象。能够保证多个线程对同一共享资源的互斥访问。同临界区有些类似，只有拥有互斥对象的线程才具有访问资源的权限，由于互斥对象只有一个，因此就决定了任何情况下此共享资源都不会同时被多个线程所访问。当前占据资源的线程在任务处理完后应将拥有的互斥对象交出，以便其他线程在获得后得以访问资源。与其他几种内核对象不同，互斥对象在操作系统中拥有特殊代码，并由操作系统来管理，操作系统甚至还允许其进行一些其他内核对象所不能进行的非常规操作。

     以互斥内核对象来保持线程同步可能用到的函数主要有CreateMutex（）、OpenMutex（）、ReleaseMutex（）、WaitForSingleObject（）和WaitForMultipleObjects（）等。在使用互斥对象前，首先要通过CreateMutex（）或OpenMutex（）创建或打开一个互斥对象。CreateMutex（）函数原型为：

     HANDLE CreateMutex(
　      LPSECURITY_ATTRIBUTES lpMutexAttributes, // 安全属性指针
　      BOOL bInitialOwner, // 初始拥有者
　      LPCTSTR lpName // 互斥对象名
     );

     参数bInitialOwner主要用来控制互斥对象的初始状态。一般多将其设置为FALSE，以表明互斥对象在创建时并没有为任何线程所占有。如果在创建互斥对象时指定了对象名，那么可以在本进程其他地方或是在其他进程通过OpenMutex（）函数得到此互斥对象的句柄。OpenMutex（）函数原型为：

    HANDLE OpenMutex(
　     DWORD dwDesiredAccess, // 访问标志
　     BOOL bInheritHandle, // 继承标志
　     LPCTSTR lpName // 互斥对象名
    );

     当目前对资源具有访问权的线程不再需要访问此资源而要离开时，必须通过ReleaseMutex（）函数来释放其拥有的互斥对象，其函数原型为：

    BOOL ReleaseMutex(HANDLE hMutex);

    其唯一的参数hMutex为待释放的互斥对象句柄。至于WaitForSingleObject（）和WaitForMultipleObjects（）等待函数在互斥对象保持线程同步中所起的作用与在其他内核对象中的作用是基本一致的，也是等待互斥内核对象的通知。但是这里需要特别指出的是：在互斥对象通知引起调用等待函数返回时，等待函数的返回值不再是通常的WAIT_OBJECT_0（对于WaitForSingleObject（）函数）或是在WAIT_OBJECT_0到WAIT_OBJECT_0+nCount-1之间的一个值（对于WaitForMultipleObjects（）函数），而是将返回一个WAIT_ABANDONED_0（对于WaitForSingleObject（）函数）或是在WAIT_ABANDONED_0到WAIT_ABANDONED_0+nCount-1之间的一个值（对于WaitForMultipleObjects（）函数）。以此来表明线程正在等待的互斥对象由另外一个线程所拥有，而此线程却在使用完共享资源前就已经终止。除此之外，使用互斥对象的方法在等待线程的可调度性上同使用其他几种内核对象的方法也有所不同，其他内核对象在没有得到通知时，受调用等待函数的作用，线程将会挂起，同时失去可调度性，而使用互斥的方法却可以在等待的同时仍具有可调度性，这也正是互斥对象所能完成的非常规操作之一。
　　在编写程序时，互斥对象多用在对那些为多个线程所访问的内存块的保护上，可以确保任何线程在处理此内存块时都对其拥有可靠的独占访问权。下面给出的示例代码即通过互斥内核对象hMutex对共享内存快g_cArray[]进行线程的独占访问保护。下面给出实现代码清单：

//  互斥对象
HANDLE hMutex  =  NULL;
char  g_cArray[ 10 ];
UINT ThreadProc18(LPVOID pParam)
{
　 //  等待互斥对象通知
　WaitForSingleObject(hMutex, INFINITE);
　 //  对共享资源进行写入操作
　 for  ( int  i  =   0 ; i  <   10 ; i ++ )
　{
　　g_cArray[i]  =   ' a ' ;
　　Sleep( 1 );
　}
　 //  释放互斥对象
　ReleaseMutex(hMutex);
　 return   0 ;
}
UINT ThreadProc19(LPVOID pParam)
{
　 //  等待互斥对象通知
　WaitForSingleObject(hMutex, INFINITE);
　 //  对共享资源进行写入操作
　 for  ( int  i  =   0 ; i  <   10 ; i ++ )
　{
　　g_cArray[ 10   -  i  -   1 ]  =   ' b ' ;
　　Sleep( 1 );
　}
　 //  释放互斥对象
　ReleaseMutex(hMutex);
　 return   0 ;
}
……
void  CSample08View::OnMutex() 
{
　 //  创建互斥对象
　hMutex  =  CreateMutex(NULL, FALSE, NULL);
　 //  启动线程
　AfxBeginThread(ThreadProc18, NULL);
　AfxBeginThread(ThreadProc19, NULL);
　 //  等待计算完毕
　Sleep( 300 );
　 //  报告计算结果
　CString sResult  =  CString(g_cArray);
　AfxMessageBox(sResult);
} 

     互斥对象在MFC中通过CMutex类进行表述。使用CMutex类的方法非常简单，在构造CMutex类对象的同时可以指明待查询的互斥对象的名字，在构造函数返回后即可访问此互斥变量。CMutex类也是只含有构造函数这唯一的成员函数，当完成对互斥对象保护资源的访问后，可通过调用从父类CSyncObject继承的UnLock（）函数完成对互斥对象的释放。CMutex类构造函数原型为：
     CMutex( BOOL bInitiallyOwn = FALSE, LPCTSTR lpszName = NULL, LPSECURITY_ATTRIBUTES lpsaAttribute = NULL );

    该类的适用范围和实现原理与API方式创建的互斥内核对象是完全类似的，但要简洁的多，下面给出就是对前面的示例代码经CMutex类改写后的程序实现清单：

CMutex g_clsMutex(FALSE, NULL);     //  MFC互斥类对象

UINT ThreadProc27(LPVOID pParam)
{
　g_clsMutex.Lock();　                //  等待互斥对象通知

　 for  ( int  i  =   0 ; i  <   10 ; i ++ )　     //  对共享资源进行写入操作
　{
　　g_cArray[i]  =   ' a ' ;
　　Sleep( 1 );
　}

　g_clsMutex.Unlock();　             //  释放互斥对象
　 return   0 ;
}
UINT ThreadProc28(LPVOID pParam)
{
　g_clsMutex.Lock();

　 for  ( int  i  =   0 ; i  <   10 ; i ++ )
　{
　　g_cArray[ 10   -  i  -   1 ]  =   ' b ' ;
　　Sleep( 1 );
　}

　g_clsMutex.Unlock();
　 return   0 ;
}
……
void  CSample08View::OnMutexMfc() 
{
　AfxBeginThread(ThreadProc27, NULL);
　AfxBeginThread(ThreadProc28, NULL);

　Sleep( 300 );

　CString sResult  =  CString(g_cArray);
　AfxMessageBox(sResult);
}