3.2线程同步

线程同步

同步可以保证在一个时间内只有一个线程对某个共享资源有控制权。共享资源包括全局变量、公共数据成员或者句柄等。临界区内核对象和事件内核对象可以很好地用于多线程同步和它们之间的通信。

临界区对象

为什么要线程同步
当多个线程在同一个进程中执行时，可能有不止一个线程同时执行同一段代码，访问同一段内存中的数据。多个线程同时读共享数据没有问题，但如果同时读和写，情况就不同了。下面是一个有问题的程序，该程序用两个线程来同时增加全局变量 g_nCount1 和 g_nCount2 的计数，运行 1 秒之后打印出计数结果。
CountErr.cpp

#include <stdio.h>
#include <windows.h> 
#include <process.h>

int g_nCount1 = 0;
int g_nCount2 = 0;
BOOL g_bContinue = TRUE;

UINT __stdcall ThreadFunc(LPVOID);

int main(int argc, char* argv[])
{
	UINT uId;
	HANDLE h[2];
	
	h[0] = (HANDLE)::_beginthreadex(NULL, 0, ThreadFunc, NULL, 0, &uId);
	h[1] = (HANDLE)::_beginthreadex(NULL, 0, ThreadFunc, NULL, 0, &uId);


	// 等待1秒后通知两个计数线程结束，关闭句柄
	Sleep(1000);
	g_bContinue = FALSE;
	::WaitForMultipleObjects(2, h, TRUE, INFINITE);
	::CloseHandle(h[0]);
	::CloseHandle(h[1]);
	
	printf("g_nCount1 = %d \n", g_nCount1);
	printf("g_nCount2 = %d \n", g_nCount2);

	return 0;
}

UINT __stdcall ThreadFunc(LPVOID)
{
	while(g_bContinue)
	{
		g_nCount1++;
		g_nCount2++;
	}
	return 0;
}

线程函数 ThreadFunc 同时增加全局变量 g_nCount1 和 g_nCount2 的计数。按道理来说最终在主线程中输出的它们的值应该是相同的，可是结果并不尽如人意，图所示是运行上面的代码，并等待 1 秒后程序的输出。

g_nCount1 和 g_nCount2 的值并不相同。出现这种结果主要是因为同时访问 g_nCount1 和g_nCount2 的两个线程具有相同的优先级。在执行过程中如果第一个线程取走 g_nCount1 的值准备进行自加操作的时候，它的时间片恰好用完，系统切换到第二个线程去对 g_nCount1 进行自加操作；一个时间片过后，第一个线程再次被调度，此时它会将上次取出的值自加，并放入g_nCount1 所在的内存里，这就会覆盖掉第二个线程对 g_nCount1 的自加操作。变量 g_nCount2也存在相同的问题。由于这样的事情的发生次数是不可预知的，所以最终的值就不相同了。

例子中，g_nCount1 和 g_nCount2 是全局变量，属于该进程内所有线程共有的资源。多线程同步就要保证在一个线程占有公共资源的时候，其他线程不会再次占有这个资源。所以，解决同步问题，就是保证整个存取过程的独占性。在一个线程对某个对象进行操作的过程中，需要有某种机制阻止其他线程的操作，这就用到了临界区对象。

使用临界区对象
临界区对象是定义在数据段中的一个 CRITICAL_SECTION 结构，Windows 内部使用这个结构记录一些信息，确保在同一时间只有一个线程访问该数据段中的数据。

编程的时候，要把临界区对象定义在想保护的数据段中，然后在任何线程使用此临界区对象之前对它进行初始化。

void InitializeCriticalSection(LPCRITICAL_SECTION lpCriticalSection ); 
// 指向数据段中定义的CRITICAL_SECTION 结构

之后，线程访问临界区中数据的时候，必须首先调用 EnterCriticalSection 函数，申请进入临界区（又叫关键代码段）。在同一时间内，Windows 只允许一个线程进入临界区。所以在申请的时候，如果有另一个线程在临界区的话，EnterCriticalSection 函数会一直等待下去，直到其他线程离开临界区才返回。EnterCriticalSection 函数用法如下。

void EnterCriticalSection( LPCRITICAL_SECTION lpCriticalSection);

当操作完成的时候，还要将临界区交还给 Windows，以便其他线程可以申请使用。这个工作由 LeaveCriticalSection 函数来完成。

void LeaveCriticalSection( LPCRITICAL_SECTION lpCriticalSection);

当程序不再使用临界区对象的时候，必须使用 DeleteCriticalSection 函数将它删除。

void DeleteCriticalSection( LPCRITICAL_SECTION lpCriticalSection);

现在使用临界区对象来改写上面有同步问题的计数程序。
CriticalSection.cpp

// CriticalSection.cpp
#include <stdio.h>
#include <windows.h>
#include <process.h>

BOOL g_bContinue = TRUE;
int g_nCount1 = 0;
int g_nCount2 = 0;
CRITICAL_SECTION g_cs; //对存在同步问题的代码段使用临界区对象

UINT __stdcall ThreadFunc(LPVOID);

int main(int argc, char* argv[])
{
	UINT uId;
	HANDLE h[2];

	// 初始化临界区对象
	::InitializeCriticalSection(&g_cs);

	h[0] = (HANDLE)::_beginthreadex(NULL, 0, ThreadFunc, NULL, 0, &uId);
	h[1] = (HANDLE)::_beginthreadex(NULL, 0, ThreadFunc, NULL, 0, &uId);

	//等待1秒后通知两个计数线程结束，关闭句柄
	Sleep(1000);
	g_bContinue = FALSE;
	::WaitForMultipleObjects(2, h, TRUE, INFINITE);
	::CloseHandle(h[0]);
	::CloseHandle(h[1]);

	//删除临界区对象
	::DeleteCriticalSection(&g_cs);
	
	printf("g_nCount1 = %d \n", g_nCount1);
	printf("g_nCount2 = %d \n", g_nCount2);

	return 0;
}

UINT __stdcall ThreadFunc(LPVOID)
{
	while(g_bContinue)
	{
		::EnterCriticalSection(&g_cs);
		g_nCount1++;
		g_nCount2++;
		::LeaveCriticalSection(&g_cs);
	}
	return 0;
}

运行这段代码，两个值的最终结果是相同的。

临界区对象能够很好地保护共享数据，但是它不能够用于进程之间资源的锁定，因为它不
是内核对象。如果要在进程间维持线程的同步可以使用事件内核对象。

互锁函数

互锁函数为同步访问多线程共享变量提供了一个简单的机制。如果变量在共享内存，不同进程的线程也可以使用此机制。用于互锁的函数有 InterlockedIncrement、InterlockedDecrement、InterlockedExchangeAdd、InterlockedExchangePointer 等，这里仅介绍前两个。

InterlockedIncrement 函数递增（加 1）指定的 32 位变量。这个函数可以阻止其他线程同时使用此变量，函数原型如下。

LONG InterlockedIncrement( LONG volatile* Addend); //指向要递增的变量

InterlockedDecrement 函数同步递减（减 1）指定的 32 位变量，原型如下。

LONG InterlockedDecrement( LONG volatile* Addend); //指向要递减的变量

函数用法相当简单，例如在03CountErr实例中，为了同步对全局变量g_nCount1、g_nCount2的访问，可以如下修改线程函数。
InterlockDemo.cpp

#include <stdio.h>
#include <windows.h> 
#include <process.h>

int g_nCount1 = 0;
int g_nCount2 = 0;
BOOL g_bContinue = TRUE;

UINT __stdcall ThreadFunc(LPVOID);

int main(int argc, char* argv[])
{
	UINT uId;
	HANDLE h[2];
	
	h[0] = (HANDLE)::_beginthreadex(NULL, 0, ThreadFunc, NULL, 0, &uId);
	h[1] = (HANDLE)::_beginthreadex(NULL, 0, ThreadFunc, NULL, 0, &uId);


	//等待1秒后通知两个计数线程结束，关闭句柄
	Sleep(1000);
	g_bContinue = FALSE;
	::WaitForMultipleObjects(2, h, TRUE, INFINITE);
	::CloseHandle(h[0]);
	::CloseHandle(h[1]);
	
	printf("g_nCount1 = %d \n", g_nCount1);
	printf("g_nCount2 = %d \n", g_nCount2);

	return 0;
}

UINT __stdcall ThreadFunc(LPVOID)
{
	while(g_bContinue)
	{
		::InterlockedIncrement((long*)&g_nCount1);
		::InterlockedIncrement((long*)&g_nCount2);
	}
	return 0;
}

事件内核对象

多线程程序设计大多会涉及线程间相互通信。使用编程就要涉及到线程的问题。主线程在
创建工作线程的时候，可以通过参数给工作线程传递初始化数据，当工作线程开始运行后，还需要通过通信机制来控制工作线程。同样，工作线程有时候也需要将一些情况主动通知主线程。一种比较好的通信方法是使用事件内核对象。

事件对象（event）是一种抽象的对象，它也有未受信（nonsignaled）和受信(signaled）两种状态，编程人员也可以使用 WaitForSingleObject 函数等待其变成受信状态。不同于其他内核对象的是一些函数可以使事件对象在这两种状态之间转化。可以把事件对象看成是一个设置在Windows 内部的标志，它的状态设置和测试工作由 Windows 来完成。

事件对象包含 3 个成员：nUsageCount (使用计数)、bManualReset（是否人工重置）和
bSignaled（是否受信）。成员 nUsageCount 记录了当前的使用计数，当使用计数为 0 的时候，Windows 就会销毁此内核对象占用的资源；成员 bManualReset 指定在一个事件内核对象上等待的函数返回之后，Windows 是否重置这个对象为未受信状态；成员 bSignaled 指定当前事件内核对象是否受信。下面要介绍的操作事件内核对象的函数会影响这些成员的值。

基本函数
如果想使用事件对象，需要首先用 CreateEvent 函数去创建它，初始状态下，nUsageCount的值为 1。

HANDLE CreateEvent( 
   LPSECURITY_ATTRIBUTES lpEventAttributes, //用来定义事件对象的安全属性
   BOOL bManualReset, //指定是否需要手动重置事件对象为未受信状态。
   BOOL bInitialState, //指定事件对象创建时的初始状态
   LPCWSTR lpName); //事件对象的名称

参数 bManualReset 对应着内核对象中的 bManualReset 成员。自动重置（auto-reset）和人工重置（manual-reset）是事件内核对象两种不同的类型。当一个人工重置的事件对象受信以后，所有等待在这个事件上的线程都会变为可调度状态；可是当一个自动重置的事件对象受信以后，Windows 仅允许一个等待在该事件上的线程变成可调度状态，然后就自动重置此事件对象为未受信状态。

bInitialState 参数对应着 bSignaled 成员。将它设为 TRUE，则表示事件对象创建时的初始化状态为受信（bSignaled = TRUE）；设为 FALSE 时，状态为未受信（bSignaled = FALSE）。

lpName 参数用来指定事件对象的名称。为事件对象命名是为了在其他地方（比如，其他进程的线程中）使用 OpenEvent 或 CreateEvent 函数获取此内核对象的句柄。

HANDLE OpenEvent ( 
   DWORD dwDesiredAccess, // 指定想要的访问权限
   BOOL bInheritHandle, // 指定返回句柄是否可被继承
   LPCWSTR lpName); // 要打开的事件对象的名称

系统创建或打开一个事件内核对象后，会返回事件的句柄。当编程人员不使用此内核对象的时候，应该调用 CloseHandle 函数释放它占用的资源。

事件对象被建立后，程序可以通过 SetEvent 和 ResetEvent 函数来设置它的状态。

BOOL SetEvent( HANDLE hEvent ); // 将事件状态设为 “受信（sigaled）”；
BOOL ResetEvent(HANDLE hEvent ); // 将事件状态设为 “未受信（nonsigaled）”；

hEvent 参数是事件对象的句柄，这个句柄可以通过 CreateEvent 或 OpenEvent 函数获得。

对于一个自动重置类型的事件对象，Microsoft 定义了一套比较实用的规则：当在这样的事件对象上等待的函数（比如，WaitForSingleObject 函数）返回时，Windows 会自动重置事件对象为未受信状态。通常情况下，为一个自动重置类型的事件对象调用 ResetEvent 函数是不必要的，因为 Windows 会自动重置此事件对象。

应用举例
下面例子中，主线程通过将事件状态设为“受信”来通知子线程开始工作。这是事件内核对象一个很重要的用途，示例代码如下。
EventDemo.cpp

#include <stdio.h>
#include <windows.h>
#include <process.h>

HANDLE g_hEvent;
UINT __stdcall ChildFunc(LPVOID);

int main(int argc, char* argv[])
{
	HANDLE hChildThread;
	UINT uId;

	// 创建一个自动重置的（auto-reset events），未受信的（nonsignaled）事件内核对象
	g_hEvent = ::CreateEvent(NULL, FALSE, FALSE, NULL);

	hChildThread = (HANDLE)::_beginthreadex(NULL, 0, ChildFunc, NULL, 0, &uId);

	// 通知子线程开始工作
	printf("Please input a char to tell the Child Thread to work: \n");
	getchar();
	::SetEvent(g_hEvent);

	// 等待子线程完成工作，释放资源
	::WaitForSingleObject(hChildThread, INFINITE);
	printf("All the work has been finished. \n");
	::CloseHandle(hChildThread);
	::CloseHandle(g_hEvent);
	return 0;
}

UINT __stdcall ChildFunc(LPVOID)
{
	::WaitForSingleObject(g_hEvent, INFINITE);
	printf("  Child thread is working...... \n");
	::Sleep(5*1000); // 暂停5秒，模拟真正的工作
	return 0;
}

运行程序，输入一个字符通知子线程开始工作。

主线程一开始，就创建了一个自动重置的（auto-reset），未受信的（nonsignaled）事件内核对象，并用全局变量 g_hEvent 保存对象的句柄。这样做会使本进程的其他线程访问此内核对象更加容易。接着子线程被创建，并等待主线程的通知来开始真正的工作。最后，子线程工作结束，主线程退出。

事件对象主要用于线程间通信，因为它是一个内核对象，所以也可以跨进程使用。依靠在线程间通信就可以使各线程的工作协调进行，达到同步的目的。

线程局部存储（TLS）

线程局部存储（thread-local storage, TLS）是一个使用很方便的存储线程局部数据的系统。利用 TLS 机制可以为进程中所有的线程关联若干个数据，各个线程通过由 TLS 分配的全局索引来访问与自己关联的数据。这样，每个线程都可以有线程局部的静态存储数据。

用于管理 TLS 的数据结构是很简单的，Windows 仅为系统中的每一个进程维护一个位数组，再为该进程中的每一个线程申请一个同样长度的数组空间，如图所示。

运行在系统中的每一个进程都有上图所示的一个位数组。位数组的成员是一个标志，每个标志的值被设为 FREE 或 INUSE，指示了此标志对应的数组索引是否在使用中。Windows 保证至少有 TLS_MINIMUM_AVAILABLE（定义在 WinNT.h 文件中）个标志位可用。

动态使用 TLS 典型步骤如下。
（1）主线程调用 TlsAlloc 函数为线程局部存储分配索引，函数原型为。

DWORD TlsAlloc(void); // 返回一个TLS 索引

如上所述，系统为每一个进程都维护着一个长度为 TLS_MINIMUM_AVAILABLE 的位数组，TlsAlloc 的返回值就是数组的一个下标（索引）。这个位数组的惟一用途就是记忆哪一个下标在使用中。初始状态下，此位数组成员的值都是 FREE，表示未被使用。当调用 TlsAlloc的时候，系统会挨个检查这个数组中成员的值，直到找到一个值为 FREE 的成员。把找到的成员的值由 FREE 改为 INUSE 后，TlsAlloc 函数返回该成员的索引。如果不能找到一个值为 FREE的成员，TlsAlloc 函数就返回 TLS_OUT_OF_INDEXES（在 WinBase.h 文件中定义为－1），意味着失败。

例如，在第一次调用 TlsAlloc 的时候，系统发现位数组中第一个成员的值是 FREE，它就将此成员的值改为 INUSE，然后返回 0。

当一个线程被创建时，Windows 就会在进程地址空间中为该线程分配一个长度为TLS_MINIMUM_AVAILABLE 的数组，数组成员的值都被初始化为 0。在内部，系统将此数组与该线程关联起来，保证只能在该线程中访问此数组中的数据。如图 3.7 所示，每个线程都有它自己的数组，数组成员可以存储任何数据。

（2）每个线程调用 TlsSetValue 和 TlsGetValue 设置或读取线程数组中的值，函数原型为。

BOOL TlsSetValue( 
  DWORD dwTlsIndex, //TLS 索引
  LPVOID lpTlsValue //要设置的值
); 
LPVOID TlsGetValue(DWORD dwTlsIndex ); // TLS 索引

TlsSetValue 函数将参数 lpTlsValue 指定的值放入索引为 dwTlsIndex 的线程数组成员中。这样，lpTlsValue 的值就与调用 TlsSetValue 函数的线程关联了起来。此函数调用成功，会返回TRUE。

调用 TlsSetValue 函数，一个线程只能改变自己线程数组中成员的值，而没有办法为另一个线程设置 TLS 值。到现在为止，将数据从一个线程传到另一个线程的惟一方法是在创建线程时使用线程函数的参数。

TlsGetValue 函数的作用是取得线程数组中索引为 dwTlsIndex 的成员的值。

TlsSetValue 和 TlsGetValue 分别用于设置和取得线程数组中的特定成员的值，而它们使用的索引就是 TlsAlloc 函数的返回值。这就充分说明了进程中惟一的位数组和各线程数组的关系。例如，TlsAlloc 返回 3，那就说明索引 3 被此进程中的每一个正在运行的和以后要被创建的线程保存了起来，用以访问各自线程数组中对应的成员的值。

（3）主线程调用 TlsFree 释放局部存储索引。函数的惟一参数是 TlsAlloc 返回的索引。

利用 TLS 可以给特定的线程关联一个数据。比如下面的例子将每个线程的创建时间与该线程关联了起来，这样，在线程终止的时候就可以得到线程的生命周期。整个跟踪线程运行时间的例子的代码如下。
03UseTLS.cpp

#include <stdio.h>
#include <windows.h>
#include <process.h>

//利用TLS记录线程的运行时间

DWORD g_tlsUsedTime;
void InitStartTime();
DWORD GetUsedTime();


UINT __stdcall ThreadFunc(LPVOID)
{
	int i;

	//初始化开始时间
	InitStartTime();

	//模拟长时间工作
	i = 10000*10000;
	while(i--) { }

	//打印出本线程运行的时间
	printf(" This thread is coming to end. Thread ID: %-5d, Used Time: %d \n", 
						::GetCurrentThreadId(), GetUsedTime());
	return 0;
}

int main(int argc, char* argv[])
{
	UINT uId;
	int i;
	HANDLE h[10];

	//通过在进程位数组中申请一个索引，初始化线程运行时间记录系统
	g_tlsUsedTime = ::TlsAlloc(); 

	//令十个线程同时运行，并等待它们各自的输出结果
	for(i=0; i<10; i++)
	{
		h[i] = (HANDLE)::_beginthreadex(NULL, 0, ThreadFunc, NULL, 0, &uId);
	}
	for(i=0; i<10; i++)
	{
		::WaitForSingleObject(h[i], INFINITE);
		::CloseHandle(h[i]);
	}

	//通过释放线程局部存储索引，释放时间记录系统占用的资源
	::TlsFree(g_tlsUsedTime);
	return 0;
}

//初始化线程的开始时间
void InitStartTime()
{
	//获得当前时间，将线程的创建时间与线程对象相关联
	DWORD dwStart = ::GetTickCount();
	::TlsSetValue(g_tlsUsedTime, (LPVOID)dwStart);
}

//取得一个线程已经运行的时间
DWORD GetUsedTime()
{
	//获得当前时间，返回当前时间和线程创建时间的差值
	DWORD dwElapsed = ::GetTickCount();
	dwElapsed = dwElapsed - (DWORD)::TlsGetValue(g_tlsUsedTime);
	return dwElapsed;
}

GetTickCount 函数可以取得 Windows 从启动开始经过的时间，其返回值是以毫秒为单位的已启动的时间。

一般情况下，为各线程分配 TLS 索引的工作要在主线程中完成，而分配的索引值应该保存在全局变量中，以方便各线程访问。上面的例子代码很清除地说明了这一点。主线程一开始就使用 TlsAlloc 为时间跟踪系统申请了一个索引，保存在全局变量 g_tlsUsedTime 中。之后，为了示例 TLS 机制的特点同时创建了 10 个线程。这 10 个线程最后都打印出了自己的生命周期，如图所示。

这个简单的线程运行时间记录系统仅提供InitStartTime和GetUsedTime两个函数供用户使用。应该在线程一开始就调用 InitStartTime 函数，此函数得到当前时间后，调用 TlsSetValue将线程的创建时间保存在以 g_tlsUsedTime 为索引的线程数组中。当想查看线程的运行时间时，直接调用 GetUsedTime 函数就行了。这个函数使用 TlsGetValue 取得线程的创建时间，然后返回当前时间和创建时间的差值。

另外用于线程同步的内核对象还有互斥体和信号量，它们的用法也比较简单，这里就不介绍了。