多线程程序设计(二)

通过前面的介绍，我们了解到了通过线程的并行和异步执行，给我们的程序带来的好处。但正如事物都是有两面性的，在享受线程给我们的应用程序带来的好处的时候，我们同时也应该解决它给我们所带来的问题，即线程同步问题。试想当有一个读线程和一个写线程同时操作一个链表，当读线程读取链表的一个节点的时候，由于系统的调度，此时写线程获得了执行的机会，并对同一个节点执行了写操作，并且最后完成了该操作。当系统再次调度读线程读取链表该节点内容的时候，该内容由于已经被写线程修改，导致我们读出了错误的数据。为了解决线程的同步问题，人们定义了临界资源这个概念。临界资源规定该资源一次只允许一个进程/ 线程对其进行访问，在此基础上，人们又定义出了临界区（critical section ）这个概念，即在每个进程/ 线程中访问临界资源的那段代码叫做临界区。在Windows 平台下面，微软已经为我们实现了临界区，以方便我们进行线程间的同步。与其它的同步方式相比，由于临界区工作在用户模式下，不需要在同步的时候进行用户模式到内核模式下的切换，所以它比其它使用内核的同步方式比较起来效率更高。但也因为其没有工作在内核模式下的原因，临界区不能够跨越进程进行同步，它只能同步同一个进程中的各个线程。下面我们来看一下操作临界区所需要了解的几个函数：

我们使用InitializeCriticalSection 或者InitializeCriticalSectionAndSpinCount 来初始化临界区结构CRITICAL_SECTION 。然后在需要访问临界资源的时候，我们需要调用EnterCriticalSection 或者TryEnterCriticalSection 来独占访问该资源。在我们完成对临界资源的访问后，我们需要调用LeaveCriticalSection ，以便让其它的线程能够访问该临界资源。在不需要该临界区对象后，我们需要调用DeleteCriticalSection 来删除该临界区。

为了使程序更加的高效，我们可以使用旋转锁和临界区进行配合。由于系统在进行线程调度的时候会将正在运行线程的状态保存下来，例如指令指针和函数调用栈等。以便在调度程序再次调度该线程执行的时候，可以让线程恢复到上次执行时的状态再次执行。这个过程叫做线程的上下文切换。由于这个过程需要使用大量的CPU 指令，所以我们需要尽量减少这个切换。这也是为什么在一个真实的服务器程序中，并不能为大量同时到来的每一个请求创建一个线程的原因。所以，为了减少线程的上下文切换，我们需要在那个线程中做一些事情，例如做一些空的循环来进行等待。是的，这就是旋转锁的概念，比起旋转锁这个看起来高深的词，实际上它确实很简单。不过在使用旋转锁的时候，我们需要注意两点，一是对于临界资源，你需要确定你可以在很少的循环次数内获得该资源，以免因为做大量的循环进行等待而消耗了大量的CPU 资源。二是对于单核CPU 的时候，绝对不要使用旋转锁。因为在旋转锁的循环结束之前，调度程序是不会调度另外一个线程执行的。

如前面看到的，Windows 为我们提供了API 函数InitializeCriticalSectionAndSpinCount 来将旋转锁和临界区结合起来，如果我们在旋转锁结束之后获得了临界资源，则我们的线程不必进入阻塞状态，而能够直接对临界资源进行访问。如果不幸在旋转锁结束之后，我们的线程还是没有能够获得对临界资源的独占访问权限，那我们的线程就不得不进入阻塞状态，等待获得该临界资源的独占访问权限后再次执行。对于旋转锁所需要循环的值，需要对自己程序做出各种各样的测试才能得到一个完美的数字。如果你没有时间来做这样一个测试，那么对你来说，4000 是一个不错的选择。

下面就让我们来看一个示例程序，看临界区和旋转锁是如何工作的。见程序CriticalSection 。

#include <stdio.h> #include <stdlib.h> #include <string.h> #include <assert.h> #include <Windows.h> #include <process.h> unsigned __stdcall ThreadProc(void *pvParam); typedef struct tagThreadParam { unsigned uThreadID; char pszMessage[32]; LPCRITICAL_SECTION pcs; }ThreadParam; #define ROUGHLY_SPIN_COUNT 4000 #define THREAD_COUNT 5 int main() { // 初始化临界区和旋转锁 CRITICAL_SECTION cs; if (!InitializeCriticalSectionAndSpinCount(&cs, // 构造的临界区 ROUGHLY_SPIN_COUNT)) // 旋转锁迭代的次数 { assert(0); return EXIT_FAILURE; } // 构造多个线程对临界区进行测试 ThreadParam tp[THREAD_COUNT]; HANDLE h[THREAD_COUNT]; for (int i = 0; i < THREAD_COUNT; ++i) { tp[i].uThreadID = 0; strcpy(tp[i].pszMessage, "Hello World!!!"); tp[i].pcs = &cs; h[i] = (HANDLE)_beginthreadex(NULL, 0, ThreadProc, &tp[i], CREATE_SUSPENDED, &tp[i].uThreadID); if (NULL == h[i]) { assert(0); return EXIT_FAILURE; } } // 恢复在构造线程时候被挂起的线程 for (int i = 0; i < THREAD_COUNT; ++i) { if (-1 == ResumeThread(h[i])) { assert(0); return EXIT_FAILURE; } } // 等待多个线程执行结束 if (WAIT_OBJECT_0 != WaitForMultipleObjects( THREAD_COUNT, // 要等待线程内核对象的数量 h, // 线程内核对象数组 TRUE, // 是否等待全部线程内核对象有信号（线程执行完毕） INFINITE)) // 等待时间 { assert(0); return EXIT_FAILURE; } // 关闭线程内核对象 for (int i = 0; i < THREAD_COUNT; ++i) { CloseHandle(h[i]); h[i] = NULL; } // 删除临界区 DeleteCriticalSection(&cs); system("pause"); return EXIT_SUCCESS; } unsigned __stdcall ThreadProc(void *pvParam) { ThreadParam *ptp = (ThreadParam*)pvParam; EnterCriticalSection(ptp->pcs); // 进入临界区，访问临界资源控制台 for (int i = 0; i <= 3; ++i) { printf("Thread %d: %s/r/n", ptp->uThreadID, ptp->pszMessage); } LeaveCriticalSection(ptp->pcs); // 离开临界区，完成对临界资源控制台的访问 return 0; } 

在介绍完临界区过后，下面让我们来看一个经典的同步问题，生产者消费者问题。该问题的描述如下：假设有X 个生产者和Y 个消费者同时操作一块大小为Z 的缓冲区。生产者可以在缓冲区未满的情况下，向缓冲区中生产物品。而消费者可以在缓冲区中有物品的时候，消费缓冲区中的物品。分析这个问题后我们可以发现，对于生产者来说，我们需要在缓冲区未满的情况下生产物品，而在缓冲区已满的情况下，我们的生产者应该停下来，等待消费者消费了物品后，在进行生产。而对于消费者来说，我们需要在缓冲区中有物品的情况下消费物品，而在缓冲区中没有物品的情况下，我们的消费者应该停下来，等待生产者生产了物品后，再进行消费。

通过以上分析可以发现，使用临界区是无法解决该问题的。因为临界区的功能是使临界资源只能被一个线程所访问，而不能描述在该问题中类似缓冲区以及物品这样的资源的数量。所以为了解决此问题，在1965 年的时候，迪科斯彻（E.W.dikstra ）提出了信号量（semaphore ）理论以及其相关操作。迪科斯彻规定信号量在内部用整数来表示临界资源的数目，当要访问该临界资源的时候，使用P 操作来获取该临界资源，并使信号量的值减1 ；当访问完该临界资源后，使用V 操作来释放该临界资源，并使信号量的值加1 。如果信号量的值已经为0 ，则在使用P 操作时不在使信号量的值减1 ，并且访问该资源的线程进入阻塞状态，直到使用该临界资源的其它线程使用V 操作释放至少1 个临界资源为止。此时处于阻塞状态的线程再次进入可调度的准备状态（ready ），并使信号量的值减1 。

与信号量一起提出来的还有互斥量（mutex ）这个概念。互斥量是一个特殊的信号量，因为其表示资源数目的最大值为1 。从这里可以看出来，实际上互斥量和前面提到的临界区是相似的概念，它们都是用来保证临界资源只能被唯一访问。

跟临界区一样，微软在Windows 平台下面已经为我们实现了信号量和互斥量。我们只需要使用它给我们提供的API 函数，就能使用信号量和互斥量对线程或者进程进行同步。相对于临界区，由于信号量和互斥量属于内核对象，在使用信号量或者互斥量进行同步的时候，程序会在用户模式和内核模式之间切换，导致程序的运行速度受到影响。但也因为信号量和互斥量属于内核对象，这让它们同临界区只能在同一个进程中使用不同，他们可以跨越不同的进程使用。

我们可以用CreateSemaphore 和CreateMutex 函数来创建一个信号量或者互斥量。使用OpenSemaphore 和OpenMutex 来打开一个已经存在的信号量或者互斥量。使用WaitForSingleObject 来当作P 操作，使用ReleaseSemaphore 和ReleaseMutex 来当作V 操作。

下面就让我们来看如何在Windows 中实现生产者和消费者问题。见程序ProducerConsumer 。

// 生产者消费者问题算法 // mutex m; // 一次只允许一个线程访问临界资源 // semaphore empty; // 表示还有多少缓冲区可以用于生产者生产，当该值为0时，生产者进程被阻塞 // semaphore full // 表示缓冲区中有多少生产出来的物品供消费者消费，该值为0时，消费者进程阻塞 // // p操作为原子操作，表示互斥量或者信号量的在其值不为0时减1。如果值为0，阻塞线程操作 // v操作为原子操作，表示互斥量或者信号量值加1 // product表示生产者生产物品 // consume表示消费者消费物品 // // void producer() // { // p(empty); // 如果缓冲区还有剩余空间，则生产者生产物品，否则阻塞操作，等待消费者消费物品后再生产 // p(m); // 一次只允许一个线程访问缓冲区 // product(); // 生产物品 // v(m); // 结束对临界资源的访问，释放互斥量，以便让其它线程访问 // v(full); // 生产了一个物品，所以表示物品数量的信号量full加1 // } // // void consumer() // { // p(full); // 如果缓冲区还有剩余物品，则消费者消费物品，否则阻塞操作，等待生产者生产物品后再消费 // p(m); // 一次只允许一个线程访问缓冲区 // consume(); // 消费物品 // v(m); // 结束对临界资源的访问，释放互斥量，以便让其它线程访问 // v(empty); // 消费了一个物品，所以表示缓冲区剩余空间的信号量empty加1 // } #include <stdio.h> #include <stdlib.h> #include <string.h> #include <assert.h> #include <Windows.h> #include <process.h> unsigned __stdcall Producer(void *pvParam); // 生产者线程入口函数 unsigned __stdcall Consumer(void *pvParam); // 消费者线程入口函数 typedef struct tagThreadParam { HANDLE hMutex; // 互斥量，一次只允许一个线程访问缓冲区 HANDLE hFull; // 信号量，表示缓冲区中有多少物品可供消费 HANDLE hEmpty; // 信号量，表示缓冲区中有多少空间可供生产 int *piElemCount; // 缓冲区中有多少物品 volatile BOOL bQuit; // 线程退出标识 }ThreadParam; #define PRODUCER_NUM 5 // 生产者线程数量 #define CONSUMER_NUM 8 // 消费者线程数量 #define BUF_SIZE 32 // 缓冲区大小 int main() { // WaitForMultipleObjects一次最多只能处理64个句柄 // 这里为了简单，为对其做处理 if (64 < PRODUCER_NUM + CONSUMER_NUM) { assert(0); return EXIT_FAILURE; } HANDLE hMutex = CreateMutex(NULL, // 安全描述符 FALSE, // 是否由创建该互斥量的线程获取该互斥量的访问权 NULL); // 互斥量在系统中的名称，该名称该在其它进程中使用，以便于创建它的进程共享该互斥量 if (NULL == hMutex) { assert(0); return EXIT_FAILURE; } HANDLE hFull = CreateSemaphore(NULL, // 安全描述符 0, // 信号量初始值 BUF_SIZE, // 信号量最大值 NULL); // 信号量在系统中的名称，该名称该在其它进程中使用，以便于创建它的进程共享该信号量 if (NULL == hFull) { assert(0); return EXIT_FAILURE; } HANDLE hEmpty = CreateSemaphore(NULL, BUF_SIZE, BUF_SIZE, NULL); if (NULL == hEmpty) { assert(0); return EXIT_FAILURE; } HANDLE h[PRODUCER_NUM + CONSUMER_NUM]; // 线程内核对象句柄数组 ThreadParam tp; // 线程参数 tp.hMutex = hMutex; tp.hFull = hFull; tp.hEmpty = hEmpty; int iElemCount = 0; tp.piElemCount = &iElemCount; tp.bQuit = FALSE; // 创建PRODUCER_NUM个生产者线程 for (int i = 0; i < PRODUCER_NUM; ++i) { h[i] = (HANDLE)_beginthreadex(NULL, 0, Producer, &tp, CREATE_SUSPENDED, NULL); if (NULL == h[i]) { assert(0); return EXIT_FAILURE; } } // 创建CONSUMER_NUM个消费者线程 for (int i = PRODUCER_NUM; i < PRODUCER_NUM + CONSUMER_NUM; ++i) { h[i] = (HANDLE)_beginthreadex(NULL, 0, Consumer, &tp, CREATE_SUSPENDED, NULL); if (NULL == h[i]) { assert(0); return EXIT_FAILURE; } } for (int i = 0; i < PRODUCER_NUM + CONSUMER_NUM; ++i) { if (-1 == ResumeThread(h[i])) { assert(0); return EXIT_FAILURE; } } // 按任意键销毁线程，退出程序 getchar(); tp.bQuit = TRUE; if (PRODUCER_NUM > CONSUMER_NUM) // 唤醒在所有消费者进程退出后，可能仍处于阻塞中的生产者进程 { for (;;) { long lEmpty = 0; ReleaseSemaphore(hEmpty, // 要释放信号量的句柄 1, // 要释放信号量值的大小，该值必须大于0 &lEmpty); // 释放前信号量的值 if (PRODUCER_NUM <= lEmpty) { break; } } } else if (CONSUMER_NUM > PRODUCER_NUM) // 唤醒在所有生产者进程退出后，可能仍处于阻塞中的消费者进程 { for (;;) { long lFull = 0; ReleaseSemaphore(hFull, 1, &lFull); if (CONSUMER_NUM <= lFull) { break; } } } // 等待所有生产者和消费者线程退出 if (WAIT_OBJECT_0 != WaitForMultipleObjects( PRODUCER_NUM + CONSUMER_NUM, h, TRUE, INFINITE)) { assert(0); return EXIT_FAILURE; } // 关闭所有生产者和消费者线程句柄 for (int i = 0; i < PRODUCER_NUM + CONSUMER_NUM; ++i) { CloseHandle(h[i]); h[i] = NULL; } // 关闭所有信号量和互斥量 CloseHandle(hEmpty); hEmpty = NULL; CloseHandle(hFull); hFull = NULL; CloseHandle(hMutex); hMutex = NULL; system("pause"); return EXIT_SUCCESS; } // 参考前面介绍算法的Producer函数 unsigned __stdcall Producer(void *pvParam) { ThreadParam *ptp = (ThreadParam*)pvParam; for (;;) { // 如果生产者线程数量大于消费者线程数量，在消费者线程退出后，生产者线程仍可能 // 阻塞在此处。所以只有在主线程中强制唤醒处于阻塞状态的生产者线程。当生产者线 // 程在此处被唤醒后，应该立即退出 if (ptp->bQuit) { break; } if (WAIT_OBJECT_0 != WaitForSingleObject(ptp->hEmpty, INFINITE)) { assert(0); return EXIT_FAILURE; } if (WAIT_OBJECT_0 != WaitForSingleObject(ptp->hMutex, INFINITE)) { assert(0); return EXIT_FAILURE; } if (!ptp->bQuit) { ++*ptp->piElemCount; printf("Product a elem, now elem is %d./r/n", *ptp->piElemCount); } if (!ReleaseMutex(ptp->hMutex)) { assert(0); return EXIT_FAILURE; } ReleaseSemaphore(ptp->hFull, 1, NULL); Sleep(1000); } return EXIT_SUCCESS; } // 参考前面介绍算法的Consumer函数 unsigned __stdcall Consumer(void *pvParam) { ThreadParam *ptp = (ThreadParam*)pvParam; for (;;) { if (ptp->bQuit) // 同生产者线程 { break; } if (WAIT_OBJECT_0 != WaitForSingleObject(ptp->hFull, INFINITE)) { assert(0); return EXIT_FAILURE; } if (WAIT_OBJECT_0 != WaitForSingleObject(ptp->hMutex, INFINITE)) { assert(0); return EXIT_FAILURE; } if (!ptp->bQuit) { --*ptp->piElemCount; printf("Consume a elem, now elem is %d./r/n", *ptp->piElemCount); } if (!ReleaseMutex(ptp->hMutex)) { assert(0); return EXIT_FAILURE; } ReleaseSemaphore(ptp->hEmpty, 1, NULL); Sleep(1000); } return EXIT_SUCCESS; }

下面让我们来看一下在Windows 下的另外一种用于同步的内核对象，事件（Event ）对象。该对象一般用来表示某种同步事件，例如处于阻塞状态的线程A 等待线程B 构造好一个对象后，再次执行。事件内核对象有两种状态，一种为有信号（signal ）状态，另一种为无信号（non-signal ）状态。当事件内核对象处于无信号状态的时候，当使用等待函数（wait function ），例如WaitForSingleObject 函数操作该内核对象的时候，调用该函数的线程进入阻塞状态。当事件内核对象处于有信号状态的时候，前面所述的线程重新进入准备状态。一共有两种类型事件类型，一类为自动重置事件（Auto-reset event ），另一类为手动重置事件（Manual-reset event ）。当使用等待函数操作自动重置事件的时候，等待函数返回的时候会将有信号的事件内核对象置于无信号状态。当使用等待函数操作手动重置事件的时候，等待函数不会将有信号的内核对象置于无信号状态，你必须使用API 函数ResetEvent 将事件置于无信号状态。我们使用CreateEvent 创建时间内核对象，然后使用SetEvent 函数将事件置于有信号状态，或者使用ResetEvent 将事件设置为无信号状态，再不需要事件内核对象的时候，我们使用CloseHandle 函数关闭事件内核对象。

示例代码如下所示。

#include <stdio.h> #include <stdlib.h> #include <string.h> #include <assert.h> #include <Windows.h> #include <process.h> typedef struct tagThreadParam { char *pszMessage; }ThreadParam; unsigned __stdcall ThreadProc(void *pvParam); #define EVENT_NAME TEXT("Event") // 内核事件名称 int main() { HANDLE hEvent = CreateEvent( NULL, // 安全描述符。NULL为默认值 FALSE, // 事件类型。TRUE为手动重置事件，FALSE为自动充值对象 FALSE, // 事件初始状态。TRUE为有信号，FALSE为无信号 EVENT_NAME); // 内核对象名称 if (NULL == hEvent) { assert(0); return EXIT_FAILURE; } ThreadParam tp; tp.pszMessage = NULL; HANDLE hThread = (HANDLE)_beginthreadex( NULL, 0, ThreadProc, &tp, 0, NULL); if (NULL == hThread) { assert(0); return EXIT_FAILURE; } // 等待内存分配 if (WAIT_OBJECT_0 != WaitForSingleObject( hEvent, INFINITE)) { assert(0); return EXIT_FAILURE; } if (NULL == tp.pszMessage) { assert(0); return EXIT_FAILURE; } printf("%s/r/n", tp.pszMessage); free(tp.pszMessage); tp.pszMessage = NULL; // 关闭线程内核对象 CloseHandle(hThread); hThread = NULL; // 关闭事件内核对象 CloseHandle(hEvent); hEvent = NULL; system("pause"); return EXIT_SUCCESS; } unsigned __stdcall ThreadProc(void *pvParam) { ThreadParam *ptp = (ThreadParam*)pvParam; ptp->pszMessage = (char*)malloc(32); if (NULL == ptp->pszMessage) { assert(0); return EXIT_FAILURE; } strcpy(ptp->pszMessage, "Hello World!!!"); // 打开事件内核对象 HANDLE hEvent = OpenEvent( SEMAPHORE_ALL_ACCESS, // 访问权限。所有权限 FALSE, // 继承权限。TRUE为可继承，FALSE为不可继承 EVENT_NAME); // 要打开的事件内核对象 if (NULL == hEvent) { assert(0); return EXIT_FAILURE; } if (!SetEvent(hEvent)) // 设置事件内核对象为有信号状态 { assert(0); return EXIT_FAILURE; } CloseHandle(hEvent); // 关闭打开的事件内核对象 hEvent = NULL; return EXIT_SUCCESS; }