秒杀多线程 多线程笔试面试题汇总

  系列前言（转自：http://blog.csdn.net/morewindows/article/details/7442639）

    本系列是本人参加微软亚洲研究院，腾讯研究院，迅雷面试时整理的，另外也加入一些其它IT公司如百度，阿里巴巴的笔试面试题目，因此具有很强的针对性。系列中不但会详细讲解多线程同步互斥的各种“招式”，而且会进一步的讲解多线程同步互斥的“内功心法”。有了“招式”和“内功心法”，相信你也能对多线程挥洒自如，在笔试面试中顺利的秒杀多线程试题。

              -------------------------------------华丽的分割线---------------------------------------

第一篇    多线程笔试面试题汇总

 

    多线程在笔试面试中经常出现，下面列出一些公司的多线程笔试面试题。首先是一些概念性的问答题，这些是多线程的基础知识，经常出现在面试中的第一轮面试（我参加2011年腾讯研究院实习生招聘时就被问到了几个概念性题目）。然后是一些选择题，这些一般在笔试时出现，虽然不是太难，但如果在选择题上花费大多时间无疑会对后面的编程题造成影响，因此必须迅速的解决掉。最后是综合题即难一些的问答题或是编程题。这种题目当然是最难解决了，要么会引来面试官的追问，要么就很容易考虑不周全，因此解决这类题目时一定要考虑全面和细致。

    下面就来看看这三类题目吧。

 

一．概念性问答题

第一题：线程的基本概念、线程的基本状态及状态之间的关系？

 

第二题：线程与进程的区别？

       这个题目问到的概率相当大，计算机专业考研中也常常考到。要想全部答出比较难。

 

第三题：多线程有几种实现方法，都是什么？

 

第四题：多线程同步和互斥有几种实现方法，都是什么？

       我在参加2011年迅雷校园招聘时的一面和二面都被问到这个题目，回答的好将会给面试成绩加不少分。

 

第五题：多线程同步和互斥有何异同，在什么情况下分别使用他们？举例说明。

 

二．选择题

第一题（百度笔试题）：

以下多线程对int型变量x的操作，哪几个不需要进行同步： 
A. x=y;      B. x++;    C. ++x;    D. x=1;

 

第二题（阿里巴巴笔试题）

多线程中栈与堆是公有的还是私有的

A：栈公有, 堆私有

B：栈公有，堆公有

C：栈私有, 堆公有

D：栈私有，堆私有

 

三．综合题

第一题（台湾某杀毒软件公司面试题）：

在Windows编程中互斥量与临界区比较类似，请分析一下二者的主要区别。

 

第二题：

一个全局变量tally，两个线程并发执行（代码段都是ThreadProc)，问两个线程都结束后，tally取值范围。

inttally = 0;//glable

voidThreadProc()

{

       for(inti = 1; i <= 50; i++)

              tally += 1;

}

 

第三题（某培训机构的练习题）：

子线程循环 10 次，接着主线程循环 100 次，接着又回到子线程循环 10 次，接着再回到主线程又循环 100 次，如此循环50次，试写出代码。

 

第四题（迅雷笔试题）：

编写一个程序，开启3个线程，这3个线程的ID分别为A、B、C，每个线程将自己的ID在屏幕上打印10遍，要求输出结果必须按ABC的顺序显示；如：ABCABC….依次递推。

 

第五题（Google面试题）

有四个线程1、2、3、4。线程1的功能就是输出1，线程2的功能就是输出2，以此类推.........现在有四个文件ABCD。初始都为空。现要让四个文件呈如下格式：

A：1 2 3 4 1 2....

B：2 3 4 1 2 3....

C：3 4 1 2 3 4....

D：4 1 2 3 4 1....

请设计程序。

 

下面的第六题与第七题也是在考研中或是程序员和软件设计师认证考试中的热门试题。

第六题

生产者消费者问题

这是一个非常经典的多线程题目，题目大意如下：有一个生产者在生产产品，这些产品将提供给若干个消费者去消费，为了使生产者和消费者能并发执行，在两者之间设置一个有多个缓冲区的缓冲池，生产者将它生产的产品放入一个缓冲区中，消费者可以从缓冲区中取走产品进行消费，所有生产者和消费者都是异步方式运行的，但它们必须保持同步，即不允许消费者到一个空的缓冲区中取产品，也不允许生产者向一个已经装满产品且尚未被取走的缓冲区中投放产品。

 

第七题

读者写者问题

这也是一个非常经典的多线程题目，题目大意如下：有一个写者很多读者，多个读者可以同时读文件，但写者在写文件时不允许有读者在读文件，同样有读者读时写者也不能写。

 

多线程相关题目就列举到此，如果各位有多线程方面的笔试面试题，欢迎提供给我，我将及时补上。谢谢大家。

 

下一篇《多线程第一次亲密接触 CreateThread与_beginthreadex本质区别》将从源代码的层次上讲解创建多线程的二个函数CreateThread与_beginthreadex到底有什么区别，让你明明白白的完成与多线程第一次亲密接触。

 

 

转载请标明出处，原文地址：http://blog.csdn.net/morewindows/article/details/7392749

 

下面列出目录，方便大家查看。

1．《秒杀多线程第一篇 多线程笔试面试题汇总》

2．《秒杀多线程第二篇 多线程第一次亲密接触 CreateThread与_beginthreadex本质区别》

3．《秒杀多线程第三篇 原子操作 Interlocked系列函数》

4．《秒杀多线程第四篇 一个经典多线程同步问题》

5．《秒杀多线程第五篇 经典线程同步 关键段CS》

6．《秒杀多线程第六篇 经典线程同步 事件Event》

7．《秒杀多线程第七篇 经典线程同步 互斥量Mutex》

8．《秒杀多线程第八篇 经典线程同步 信号量Semaphore》

9．《秒杀多线程第九篇 经典线程同步总结 关键段 事件 互斥量 信号量》

10．《秒杀多线程第十篇 生产者消费者问题》

11．《秒杀多线程第十一篇 读者写者问题》

12．《秒杀多线程第十二篇 多线程同步内功心法——PV操作上》

13．《秒杀多线程第十三篇 多线程同步内功心法——PV操作下》即将发布

14．《秒杀多线程第十四篇 读者写者问题继 读写锁SRWLock》

15．《秒杀多线程第十五篇 关键段,事件,互斥量,信号量的“遗弃”问题》

16.    《秒杀多线程第十六篇 多线程十大经典案例之一 双线程读写队列数据》

2. 秒杀多线程第二篇 多线程第一次亲密接触 CreateThread与_beginthreadex本质区别

 本文将带领你与多线程作第一次亲密接触，并深入分析CreateThread与_beginthreadex的本质区别，相信阅读本文后你能轻松的使用多线程并能流畅准确的回答CreateThread与_beginthreadex到底有什么区别，在实际的编程中到底应该使用CreateThread还是_beginthreadex？

 

   使用多线程其实是非常容易的，下面这个程序的主线程会创建了一个子线程并等待其运行完毕，子线程就输出它的线程ID号然后输出一句经典名言——Hello World。整个程序的代码非常简短，只有区区几行。

[cpp]  view plain copy

1. //最简单的创建多线程实例  
2. #include <stdio.h>  
3. #include <windows.h>  
4. //子线程函数  
5. DWORD WINAPI ThreadFun(LPVOID pM)  
6. {  
7.     printf("子线程的线程ID号为：%d\n子线程输出Hello World\n", GetCurrentThreadId());  
8.     return 0;  
9. }  
10. //主函数，所谓主函数其实就是主线程执行的函数。  
11. int main()  
12. {  
13.     printf("     最简单的创建多线程实例\n");  
14.     printf(" -- by MoreWindows( http://blog.csdn.net/MoreWindows ) --\n\n");  
15.   
16.     HANDLE handle = CreateThread(NULL, 0, ThreadFun, NULL, 0, NULL);  
17.     WaitForSingleObject(handle, INFINITE);  
18.     return 0;  
19. }  

运行结果如下所示：

下面来细讲下代码中的一些函数

第一个 CreateThread

函数功能：创建线程

函数原型：

HANDLEWINAPICreateThread(

  LPSECURITY_ATTRIBUTESlpThreadAttributes,

  SIZE_TdwStackSize,

  LPTHREAD_START_ROUTINElpStartAddress,

  LPVOIDlpParameter,

  DWORDdwCreationFlags,

  LPDWORDlpThreadId

);

函数说明：

第一个参数表示线程内核对象的安全属性，一般传入NULL表示使用默认设置。

第二个参数表示线程栈空间大小。传入0表示使用默认大小（1MB）。

第三个参数表示新线程所执行的线程函数地址，多个线程可以使用同一个函数地址。

第四个参数是传给线程函数的参数。

第五个参数指定额外的标志来控制线程的创建，为0表示线程创建之后立即就可以进行调度，如果为CREATE_SUSPENDED则表示线程创建后暂停运行，这样它就无法调度，直到调用ResumeThread()。

第六个参数将返回线程的ID号，传入NULL表示不需要返回该线程ID号。

函数返回值：

成功返回新线程的句柄，失败返回NULL。 

 

第二个 WaitForSingleObject

函数功能：等待函数 – 使线程进入等待状态，直到指定的内核对象被触发。

函数原形：

DWORDWINAPIWaitForSingleObject(

  HANDLEhHandle,

  DWORDdwMilliseconds

);

函数说明：

第一个参数为要等待的内核对象。

第二个参数为最长等待的时间，以毫秒为单位，如传入5000就表示5秒，传入0就立即返回，传入INFINITE表示无限等待。

因为线程的句柄在线程运行时是未触发的，线程结束运行，句柄处于触发状态。所以可以用WaitForSingleObject()来等待一个线程结束运行。

函数返回值：

在指定的时间内对象被触发，函数返回WAIT_OBJECT_0。超过最长等待时间对象仍未被触发返回WAIT_TIMEOUT。传入参数有错误将返回WAIT_FAILED

 

CreateThread()函数是Windows提供的API接口，在C/C++语言另有一个创建线程的函数_beginthreadex()，在很多书上（包括《Windows核心编程》）提到过尽量使用_beginthreadex()来代替使用CreateThread()，这是为什么了？下面就来探索与发现它们的区别吧。

 

       首先要从标准C运行库与多线程的矛盾说起，标准C运行库在1970年被实现了，由于当时没任何一个操作系统提供对多线程的支持。因此编写标准C运行库的程序员根本没考虑多线程程序使用标准C运行库的情况。比如标准C运行库的全局变量errno。很多运行库中的函数在出错时会将错误代号赋值给这个全局变量，这样可以方便调试。但如果有这样的一个代码片段：

[cpp]  view plain copy

1. if (system("notepad.exe readme.txt") == -1)  
2. {  
3.     switch(errno)  
4.     {  
5.         ...//错误处理代码  
6.     }  
7. }  

假设某个线程A在执行上面的代码，该线程在调用system()之后且尚未调用switch()语句时另外一个线程B启动了，这个线程B也调用了标准C运行库的函数，不幸的是这个函数执行出错了并将错误代号写入全局变量errno中。这样线程A一旦开始执行switch()语句时，它将访问一个被B线程改动了的errno。这种情况必须要加以避免！因为不单单是这一个变量会出问题，其它像strerror()、strtok()、tmpnam()、gmtime()、asctime()等函数也会遇到这种由多个线程访问修改导致的数据覆盖问题。

 

为了解决这个问题，Windows操作系统提供了这样的一种解决方案——每个线程都将拥有自己专用的一块内存区域来供标准C运行库中所有有需要的函数使用。而且这块内存区域的创建就是由C/C++运行库函数_beginthreadex()来负责的。下面列出_beginthreadex()函数的源代码（我在这份代码中增加了一些注释）以便读者更好的理解_beginthreadex()函数与CreateThread()函数的区别。

[cpp]  view plain copy

1. //_beginthreadex源码整理By MoreWindows( http://blog.csdn.net/MoreWindows )  
2. _MCRTIMP uintptr_t __cdecl _beginthreadex(  
3.     void *security,  
4.     unsigned stacksize,  
5.     unsigned (__CLR_OR_STD_CALL * initialcode) (void *),  
6.     void * argument,  
7.     unsigned createflag,  
8.     unsigned *thrdaddr  
9. )  
10. {  
11.     _ptiddata ptd;          //pointer to per-thread data 见注1  
12.     uintptr_t thdl;         //thread handle 线程句柄  
13.     unsigned long err = 0L; //Return from GetLastError()  
14.     unsigned dummyid;    //dummy returned thread ID 线程ID号  
15.       
16.     // validation section 检查initialcode是否为NULL  
17.     _VALIDATE_RETURN(initialcode != NULL, EINVAL, 0);  
18.   
19.     //Initialize FlsGetValue function pointer  
20.     __set_flsgetvalue();  
21.       
22.     //Allocate and initialize a per-thread data structure for the to-be-created thread.  
23.     //相当于new一个_tiddata结构，并赋给_ptiddata指针。  
24.     if ( (ptd = (_ptiddata)_calloc_crt(1, sizeof(struct _tiddata))) == NULL )  
25.         goto error_return;  
26.   
27.     // Initialize the per-thread data  
28.     //初始化线程的_tiddata块即CRT数据区域 见注2  
29.     _initptd(ptd, _getptd()->ptlocinfo);  
30.       
31.     //设置_tiddata结构中的其它数据，这样这块_tiddata块就与线程联系在一起了。  
32.     ptd->_initaddr = (void *) initialcode; //线程函数地址  
33.     ptd->_initarg = argument;              //传入的线程参数  
34.     ptd->_thandle = (uintptr_t)(-1);  
35.       
36. #if defined (_M_CEE) || defined (MRTDLL)  
37.     if(!_getdomain(&(ptd->__initDomain))) //见注3  
38.     {  
39.         goto error_return;  
40.     }  
41. #endif  // defined (_M_CEE) || defined (MRTDLL)  
42.       
43.     // Make sure non-NULL thrdaddr is passed to CreateThread  
44.     if ( thrdaddr == NULL )//判断是否需要返回线程ID号  
45.         thrdaddr = &dummyid;  
46.   
47.     // Create the new thread using the parameters supplied by the caller.  
48.     //_beginthreadex()最终还是会调用CreateThread()来向系统申请创建线程  
49.     if ( (thdl = (uintptr_t)CreateThread(  
50.                     (LPSECURITY_ATTRIBUTES)security,  
51.                     stacksize,  
52.                     _threadstartex,  
53.                     (LPVOID)ptd,  
54.                     createflag,  
55.                     (LPDWORD)thrdaddr))  
56.         == (uintptr_t)0 )  
57.     {  
58.         err = GetLastError();  
59.         goto error_return;  
60.     }  
61.   
62.     //Good return  
63.     return(thdl); //线程创建成功,返回新线程的句柄.  
64.       
65.     //Error return  
66. error_return:  
67.     //Either ptd is NULL, or it points to the no-longer-necessary block  
68.     //calloc-ed for the _tiddata struct which should now be freed up.  
69.     //回收由_calloc_crt()申请的_tiddata块  
70.     _free_crt(ptd);  
71.     // Map the error, if necessary.  
72.     // Note: this routine returns 0 for failure, just like the Win32  
73.     // API CreateThread, but _beginthread() returns -1 for failure.  
74.     //校正错误代号(可以调用GetLastError()得到错误代号)  
75.     if ( err != 0L )  
76.         _dosmaperr(err);  
77.     return( (uintptr_t)0 ); //返回值为NULL的效句柄  
78. }  

讲解下部分代码：

注1．_ptiddataptd;中的_ptiddata是个结构体指针。在mtdll.h文件被定义：

      typedefstruct_tiddata * _ptiddata

微软对它的注释为Structure for each thread's data。这是一个非常大的结构体，有很多成员。本文由于篇幅所限就不列出来了。

 

注2．_initptd(ptd, _getptd()->ptlocinfo);微软对这一句代码中的getptd()的说明为：

      /* return address of per-thread CRT data */

      _ptiddata __cdecl_getptd(void);

对_initptd()说明如下：

      /* initialize a per-thread CRT data block */

      void__cdecl_initptd(_Inout_ _ptiddata _Ptd,_In_opt_ pthreadlocinfo _Locale);

注释中的CRT （C Runtime Library）即标准C运行库。

 

注3．if(!_getdomain(&(ptd->__initDomain)))中的_getdomain()函数代码可以在thread.c文件中找到，其主要功能是初始化COM环境。

 

由上面的源代码可知，_beginthreadex()函数在创建新线程时会分配并初始化一个_tiddata块。这个_tiddata块自然是用来存放一些需要线程独享的数据。事实上新线程运行时会首先将_tiddata块与自己进一步关联起来。然后新线程调用标准C运行库函数如strtok()时就会先取得_tiddata块的地址再将需要保护的数据存入_tiddata块中。这样每个线程就只会访问和修改自己的数据而不会去篡改其它线程的数据了。因此，如果在代码中有使用标准C运行库中的函数时，尽量使用_beginthreadex()来代替CreateThread()。相信阅读到这里时，你会对这句简短的话有个非常深刻的印象，如果有面试官问起，你也可以流畅准确的回答了^_^。

 

接下来，类似于上面的程序用CreateThread()创建输出“Hello World”的子线程，下面使用_beginthreadex()来创建多个子线程：

[cpp]  view plain copy

1. //创建多子个线程实例  
2. #include <stdio.h>  
3. #include <process.h>  
4. #include <windows.h>  
5. //子线程函数  
6. unsigned int __stdcall ThreadFun(PVOID pM)  
7. {  
8.     printf("线程ID号为%4d的子线程说：Hello World\n", GetCurrentThreadId());  
9.     return 0;  
10. }  
11. //主函数，所谓主函数其实就是主线程执行的函数。  
12. int main()  
13. {  
14.     printf("     创建多个子线程实例 \n");  
15.     printf(" -- by MoreWindows( http://blog.csdn.net/MoreWindows ) --\n\n");  
16.       
17.     const int THREAD_NUM = 5;  
18.     HANDLE handle[THREAD_NUM];  
19.     for (int i = 0; i < THREAD_NUM; i++)  
20.         handle[i] = (HANDLE)_beginthreadex(NULL, 0, ThreadFun, NULL, 0, NULL);  
21.     WaitForMultipleObjects(THREAD_NUM, handle, TRUE, INFINITE);  
22.     return 0;  
23. }  

运行结果如下：

图中每个子线程说的都是同一句话，不太好看。能不能来一个线程报数功能，即第一个子线程输出1，第二个子线程输出2，第三个子线程输出3，……。要实现这个功能似乎非常简单——每个子线程对一个全局变量进行递增并输出就可以了。代码如下：

[cpp]  view plain copy

1. //子线程报数  
2. #include <stdio.h>  
3. #include <process.h>  
4. #include <windows.h>  
5. int g_nCount;  
6. //子线程函数  
7. unsigned int __stdcall ThreadFun(PVOID pM)  
8. {  
9.     g_nCount++;  
10.     printf("线程ID号为%4d的子线程报数%d\n", GetCurrentThreadId(), g_nCount);  
11.     return 0;  
12. }  
13. //主函数，所谓主函数其实就是主线程执行的函数。  
14. int main()  
15. {  
16.     printf("     子线程报数 \n");  
17.     printf(" -- by MoreWindows( http://blog.csdn.net/MoreWindows ) --\n\n");  
18.       
19.     const int THREAD_NUM = 10;  
20.     HANDLE handle[THREAD_NUM];  
21.   
22.     g_nCount = 0;  
23.     for (int i = 0; i < THREAD_NUM; i++)  
24.         handle[i] = (HANDLE)_beginthreadex(NULL, 0, ThreadFun, NULL, 0, NULL);  
25.     WaitForMultipleObjects(THREAD_NUM, handle, TRUE, INFINITE);  
26.     return 0;  
27. }  

对一次运行结果截图如下：

显示结果从1数到10，看起来好象没有问题。

       答案是不对的，虽然这种做法在逻辑上是正确的，但在多线程环境下这样做是会产生严重的问题，下一篇《秒杀多线程第三篇 原子操作 Interlocked系列函数》将为你演示错误的结果（可能非常出人意料）并解释产生这个结果的详细原因。

3. 秒杀多线程第三篇 原子操作 Interlocked系列函数

上一篇《多线程第一次亲密接触 CreateThread与_beginthreadex本质区别》中讲到一个多线程报数功能。为了描述方便和代码简洁起见，我们可以只输出最后的报数结果来观察程序是否运行出错。这也非常类似于统计一个网站每天有多少用户登录，每个用户登录用一个线程模拟，线程运行时会将一个表示计数的变量递增。程序在最后输出计数的值表示有今天多少个用户登录，如果这个值不等于我们启动的线程个数，那显然说明这个程序是有问题的。整个程序代码如下：

[cpp]  view plain copy

1. #include <stdio.h>  
2. #include <process.h>  
3. #include <windows.h>  
4. volatile long g_nLoginCount; //登录次数  
5. unsigned int __stdcall Fun(void *pPM); //线程函数  
6. const int THREAD_NUM = 10; //启动线程数  
7. unsigned int __stdcall ThreadFun(void *pPM)  
8. {  
9.     Sleep(100); //some work should to do  
10.     g_nLoginCount++;  
11.     Sleep(50);   
12.     return 0;  
13. }  
14. int main()  
15. {  
16.     g_nLoginCount = 0;  
17.   
18.     HANDLE  handle[THREAD_NUM];  
19.     for (int i = 0; i < THREAD_NUM; i++)  
20.         handle[i] = (HANDLE)_beginthreadex(NULL, 0, ThreadFun, NULL, 0, NULL);  
21.       
22.     WaitForMultipleObjects(THREAD_NUM, handle, TRUE, INFINITE);   
23.     printf("有%d个用户登录后记录结果是%d\n", THREAD_NUM, g_nLoginCount);  
24.     return 0;  
25. }  

程序中模拟的是10个用户登录，程序将输出结果：

和上一篇的线程报数程序一样，程序输出的结果好象并没什么问题。下面我们增加点用户来试试，现在模拟50个用户登录，为了便于观察结果，在程序中将50个用户登录过程重复20次，代码如下：

[cpp]  view plain copy

1. #include <stdio.h>  
2. #include <windows.h>  
3. volatile long g_nLoginCount; //登录次数  
4. unsigned int __stdcall Fun(void *pPM); //线程函数  
5. const DWORD THREAD_NUM = 50;//启动线程数  
6. DWORD WINAPI ThreadFun(void *pPM)  
7. {  
8.     Sleep(100); //some work should to do  
9.     g_nLoginCount++;  
10.     Sleep(50);  
11.     return 0;  
12. }  
13. int main()  
14. {  
15.     printf("     原子操作 Interlocked系列函数的使用\n");  
16.     printf(" -- by MoreWindows( http://blog.csdn.net/MoreWindows ) --\n\n");  
17.       
18.     //重复20次以便观察多线程访问同一资源时导致的冲突  
19.     int num= 20;  
20.     while (num--)  
21.     {     
22.         g_nLoginCount = 0;  
23.         int i;  
24.         HANDLE  handle[THREAD_NUM];  
25.         for (i = 0; i < THREAD_NUM; i++)  
26.             handle[i] = CreateThread(NULL, 0, ThreadFun, NULL, 0, NULL);  
27.         WaitForMultipleObjects(THREAD_NUM, handle, TRUE, INFINITE);  
28.         printf("有%d个用户登录后记录结果是%d\n", THREAD_NUM, g_nLoginCount);  
29.     }  
30.     return 0;  
31. }  

运行结果如下图：

现在结果水落石出，明明有50个线程执行了g_nLoginCount++;操作，但结果输出是不确定的，有可能为50，但也有可能小于50。

       要解决这个问题，我们就分析下g_nLoginCount++;操作。在VC6.0编译器对g_nLoginCount++;这一语句打个断点，再按F5进入调试状态，然后按下Debug工具栏的Disassembly按钮，这样就出现了汇编代码窗口。可以发现在C/C++语言中一条简单的自增语句其实是由三条汇编代码组成的，如下图所示。

讲解下这三条汇编意思：

第一条汇编将g_nLoginCount的值从内存中读取到寄存器eax中。

第二条汇编将寄存器eax中的值与1相加，计算结果仍存入寄存器eax中。

第三条汇编将寄存器eax中的值写回内存中。

       这样由于线程执行的并发性，很可能线程A执行到第二句时，线程B开始执行，线程B将原来的值又写入寄存器eax中，这样线程A所主要计算的值就被线程B修改了。这样执行下来，结果是不可预知的——可能会出现50，可能小于50。

       因此在多线程环境中对一个变量进行读写时，我们需要有一种方法能够保证对一个值的递增操作是原子操作——即不可打断性，一个线程在执行原子操作时，其它线程必须等待它完成之后才能开始执行该原子操作。这种涉及到硬件的操作会不会很复杂了，幸运的是，Windows系统为我们提供了一些以Interlocked开头的函数来完成这一任务（下文将这些函数称为Interlocked系列函数）。

下面列出一些常用的Interlocked系列函数：

1.增减操作

LONG__cdeclInterlockedIncrement(LONG volatile* Addend);

LONG__cdeclInterlockedDecrement(LONG volatile* Addend);

返回变量执行增减操作之后的值。

LONG__cdec InterlockedExchangeAdd(LONG volatile* Addend, LONGValue);

返回运算后的值，注意！加个负数就是减。

 

2.赋值操作

LONG__cdeclInterlockedExchange(LONG volatile* Target, LONGValue);

Value就是新值，函数会返回原先的值。

 

在本例中只要使用InterlockedIncrement()函数就可以了。将线程函数代码改成：

[cpp]  view plain copy

1. DWORD WINAPI ThreadFun(void *pPM)  
2. {  
3.     Sleep(100);//some work should to do  
4.     //g_nLoginCount++;  
5.     InterlockedIncrement((LPLONG)&g_nLoginCount);  
6.     Sleep(50);  
7.     return 0;  
8. }  

再次运行，可以发现结果会是唯一的。

       因此，在多线程环境下，我们对变量的自增自减这些简单的语句也要慎重思考，防止多个线程导致的数据访问出错。更多介绍，请访问MSDN上Synchronization Functions这一章节，地址为 http://msdn.microsoft.com/zh-cn/library/aa909196.aspx

 

看到这里，相信本系列首篇《秒杀多线程第一篇 多线程笔试面试题汇总》中选择题第一题（百度笔试题）应该可以秒杀掉了吧（知其然也知其所以然），正确答案是D。另外给个附加问题，程序中是用50个线程模拟用户登录，有兴趣的同学可以试下用100个线程来模拟一下（上机试试绝对会有意外发现^_^）。

 

下一篇《秒杀多线程第四篇 一个经典多线程同步问题》将提出一个稍为复杂点但却非常经典的多线程同步互斥问题，这个问题会采用不同的方法来解答，从而让你充分熟练多线程同步互斥的“招式”。更多精彩，欢迎继续参阅。

 

 

转载请标明出处，原文地址：http://blog.csdn.net/morewindows/article/details/7429155

如果觉得本文对您有帮助，请点击‘顶’支持一下，您的支持是我写作最大的动力，谢谢。

4. 秒杀多线程第四篇 一个经典的多线程同步问题

上一篇《秒杀多线程第三篇原子操作 Interlocked系列函数》中介绍了原子操作在多进程中的作用，现在来个复杂点的。这个问题涉及到线程的同步和互斥，是一道非常有代表性的多线程同步问题，如果能将这个问题搞清楚，那么对多线程同步也就打下了良好的基础。

 

程序描述：

主线程启动10个子线程并将表示子线程序号的变量地址作为参数传递给子线程。子线程接收参数 -> sleep(50) -> 全局变量++ -> sleep(0) -> 输出参数和全局变量。

要求：

1．子线程输出的线程序号不能重复。

2．全局变量的输出必须递增。

下面画了个简单的示意图：

分析下这个问题的考察点，主要考察点有二个：

1．主线程创建子线程并传入一个指向变量地址的指针作参数，由于线程启动须要花费一定的时间，所以在子线程根据这个指针访问并保存数据前，主线程应等待子线程保存完毕后才能改动该参数并启动下一个线程。这涉及到主线程与子线程之间的同步。

2．子线程之间会互斥的改动和输出全局变量。要求全局变量的输出必须递增。这涉及到各子线程间的互斥。

 

下面列出这个程序的基本框架，可以在此代码基础上进行修改和验证。

[cpp]  view plain copy

1. //经典线程同步互斥问题  
2. #include <stdio.h>  
3. #include <process.h>  
4. #include <windows.h>  
5.   
6. long g_nNum; //全局资源  
7. unsigned int __stdcall Fun(void *pPM); //线程函数  
8. const int THREAD_NUM = 10; //子线程个数  
9.   
10. int main()  
11. {  
12.     g_nNum = 0;  
13.     HANDLE  handle[THREAD_NUM];  
14.       
15.     int i = 0;  
16.     while (i < THREAD_NUM)   
17.     {  
18.         handle[i] = (HANDLE)_beginthreadex(NULL, 0, Fun, &i, 0, NULL);  
19.         i++;//等子线程接收到参数时主线程可能改变了这个i的值  
20.     }  
21.     //保证子线程已全部运行结束  
22.     WaitForMultipleObjects(THREAD_NUM, handle, TRUE, INFINITE);    
23.     return 0;  
24. }  
25.   
26. unsigned int __stdcall Fun(void *pPM)  
27. {  
28. //由于创建线程是要一定的开销的，所以新线程并不能第一时间执行到这来  
29.     int nThreadNum = *(int *)pPM; //子线程获取参数  
30.     Sleep(50);//some work should to do  
31.     g_nNum++;  //处理全局资源  
32.     Sleep(0);//some work should to do  
33.     printf("线程编号为%d  全局资源值为%d\n", nThreadNum, g_nNum);  
34.     return 0;  
35. }  

运行结果可以参考下列图示，强烈建议读者亲自试一试。

图1

图2

图3

可以看出，运行结果完全是混乱和不可预知的。本系列将会运用Windows平台下各种手段包括关键段，事件，互斥量，信号量等等来解决这个问题并作一份全面的总结，敬请关注。

5.  秒杀多线程第五篇 经典线程同步 关键段CS

上一篇《秒杀多线程第四篇 一个经典的多线程同步问题》提出了一个经典的多线程同步互斥问题，本篇将用关键段CRITICAL_SECTION来尝试解决这个问题。

本文首先介绍下如何使用关键段，然后再深层次的分析下关键段的实现机制与原理。

关键段CRITICAL_SECTION一共就四个函数，使用很是方便。下面是这四个函数的原型和使用说明。

 

函数功能：初始化

函数原型：

void InitializeCriticalSection(LPCRITICAL_SECTIONlpCriticalSection);

函数说明：定义关键段变量后必须先初始化。

 

函数功能：销毁

函数原型：

void DeleteCriticalSection(LPCRITICAL_SECTIONlpCriticalSection);

函数说明：用完之后记得销毁。

 

函数功能：进入关键区域

函数原型：

void EnterCriticalSection(LPCRITICAL_SECTIONlpCriticalSection);

函数说明：系统保证各线程互斥的进入关键区域。

 

函数功能：离开关关键区域

函数原型：

void LeaveCriticalSection(LPCRITICAL_SECTIONlpCriticalSection);

 

然后在经典多线程问题中设置二个关键区域。一个是主线程在递增子线程序号时，另一个是各子线程互斥的访问输出全局资源时。详见代码：

[cpp]  view plain copy

1. #include <stdio.h>  
2. #include <process.h>  
3. #include <windows.h>  
4. long g_nNum;  
5. unsigned int __stdcall Fun(void *pPM);  
6. const int THREAD_NUM = 10;  
7. //关键段变量声明  
8. CRITICAL_SECTION  g_csThreadParameter, g_csThreadCode;  
9. int main()  
10. {  
11.     printf("     经典线程同步 关键段\n");  
12.     printf(" -- by MoreWindows( http://blog.csdn.net/MoreWindows ) --\n\n");  
13.   
14.     //关键段初始化  
15.     InitializeCriticalSection(&g_csThreadParameter);  
16.     InitializeCriticalSection(&g_csThreadCode);  
17.       
18.     HANDLE  handle[THREAD_NUM];   
19.     g_nNum = 0;   
20.     int i = 0;  
21.     while (i < THREAD_NUM)   
22.     {  
23.         EnterCriticalSection(&g_csThreadParameter);//进入子线程序号关键区域  
24.         handle[i] = (HANDLE)_beginthreadex(NULL, 0, Fun, &i, 0, NULL);  
25.         ++i;  
26.     }  
27.     WaitForMultipleObjects(THREAD_NUM, handle, TRUE, INFINITE);  
28.   
29.     DeleteCriticalSection(&g_csThreadCode);  
30.     DeleteCriticalSection(&g_csThreadParameter);  
31.     return 0;  
32. }  
33. unsigned int __stdcall Fun(void *pPM)  
34. {  
35.     int nThreadNum = *(int *)pPM;   
36.     LeaveCriticalSection(&g_csThreadParameter);//离开子线程序号关键区域  
37.   
38.     Sleep(50);//some work should to do  
39.   
40.     EnterCriticalSection(&g_csThreadCode);//进入各子线程互斥区域  
41.     g_nNum++;  
42.     Sleep(0);//some work should to do  
43.     printf("线程编号为%d  全局资源值为%d\n", nThreadNum, g_nNum);  
44.     LeaveCriticalSection(&g_csThreadCode);//离开各子线程互斥区域  
45.     return 0;  
46. }  

运行结果如下图：

可以看出来，各子线程已经可以互斥的访问与输出全局资源了，但主线程与子线程之间的同步还是有点问题。

       这是为什么了？

要解开这个迷，最直接的方法就是先在程序中加上断点来查看程序的运行流程。断点处置示意如下：

然后按F5进行调试，正常来说这两个断点应该是依次轮流执行，但实际调试时却发现不是如此，主线程可以多次通过第一个断点即

       EnterCriticalSection(&g_csThreadParameter);//进入子线程序号关键区域

这一语句。这说明主线程能多次进入这个关键区域！找到主线程和子线程没能同步的原因后，下面就来分析下原因的原因吧^_^

 

先找到关键段CRITICAL_SECTION的定义吧，它在WinBase.h中被定义成RTL_CRITICAL_SECTION。而RTL_CRITICAL_SECTION在WinNT.h中声明，它其实是个结构体：

typedef struct _RTL_CRITICAL_SECTION {

    PRTL_CRITICAL_SECTION_DEBUGDebugInfo;

    LONGLockCount;

    LONGRecursionCount;

    HANDLEOwningThread; // from the thread's ClientId->UniqueThread

    HANDLELockSemaphore;

    DWORDSpinCount;

} RTL_CRITICAL_SECTION, *PRTL_CRITICAL_SECTION;

各个参数的解释如下：

第一个参数：PRTL_CRITICAL_SECTION_DEBUGDebugInfo;

调试用的。

 

第二个参数：LONGLockCount;

初始化为-1，n表示有n个线程在等待。

 

第三个参数：LONGRecursionCount;  

表示该关键段的拥有线程对此资源获得关键段次数，初为0。

 

第四个参数：HANDLEOwningThread;  

即拥有该关键段的线程句柄，微软对其注释为——from the thread's ClientId->UniqueThread

 

第五个参数：HANDLELockSemaphore;

实际上是一个自复位事件。

 

第六个参数：DWORDSpinCount;    

旋转锁的设置，单CPU下忽略

 

由这个结构可以知道关键段会记录拥有该关键段的线程句柄即关键段是有“线程所有权”概念的。事实上它会用第四个参数OwningThread来记录获准进入关键区域的线程句柄，如果这个线程再次进入，EnterCriticalSection()会更新第三个参数RecursionCount以记录该线程进入的次数并立即返回让该线程进入。其它线程调用EnterCriticalSection()则会被切换到等待状态，一旦拥有线程所有权的线程调用LeaveCriticalSection()使其进入的次数为0时，系统会自动更新关键段并将等待中的线程换回可调度状态。

因此可以将关键段比作旅馆的房卡，调用EnterCriticalSection()即申请房卡，得到房卡后自己当然是可以多次进出房间的，在你调用LeaveCriticalSection()交出房卡之前，别人自然是无法进入该房间。

回到这个经典线程同步问题上，主线程正是由于拥有“线程所有权”即房卡，所以它可以重复进入关键代码区域从而导致子线程在接收参数之前主线程就已经修改了这个参数。所以关键段可以用于线程间的互斥，但不可以用于同步。

 

另外，由于将线程切换到等待状态的开销较大，因此为了提高关键段的性能，Microsoft将旋转锁合并到关键段中，这样EnterCriticalSection()会先用一个旋转锁不断循环，尝试一段时间才会将线程切换到等待状态。下面是配合了旋转锁的关键段初始化函数

函数功能：初始化关键段并设置旋转次数

函数原型：

BOOLInitializeCriticalSectionAndSpinCount(

  LPCRITICAL_SECTIONlpCriticalSection,

  DWORDdwSpinCount);

函数说明：旋转次数一般设置为4000。

 

函数功能：修改关键段的旋转次数

函数原型：

DWORDSetCriticalSectionSpinCount(

  LPCRITICAL_SECTIONlpCriticalSection,

  DWORDdwSpinCount);

 

《Windows核心编程》第五版的第八章推荐在使用关键段的时候同时使用旋转锁，这样有助于提高性能。值得注意的是如果主机只有一个处理器，那么设置旋转锁是无效的。无法进入关键区域的线程总会被系统将其切换到等待状态。

最后总结下关键段：

1．关键段共初始化化、销毁、进入和离开关键区域四个函数。

2．关键段可以解决线程的互斥问题，但因为具有“线程所有权”，所以无法解决同步问题。

3．推荐关键段与旋转锁配合使用。

 

下一篇《秒杀多线程第六篇 经典线程同步 事件Event》将介绍使用事件Event来解决这个经典线程同步问题。

 6. 秒杀多线程第六篇 经典线程同步 事件Event

上一篇中使用关键段来解决经典的多线程同步互斥问题，由于关键段的“线程所有权”特性所以关键段只能用于线程的互斥而不能用于同步。本篇介绍用事件Event来尝试解决这个线程同步问题。

首先介绍下如何使用事件。事件Event实际上是个内核对象，它的使用非常方便。下面列出一些常用的函数。

 

第一个 CreateEvent

函数功能：创建事件

函数原型：

HANDLECreateEvent(

 LPSECURITY_ATTRIBUTESlpEventAttributes,

 BOOLbManualReset,

 BOOLbInitialState,

 LPCTSTRlpName

);

函数说明：

第一个参数表示安全控制，一般直接传入NULL。

第二个参数确定事件是手动置位还是自动置位，传入TRUE表示手动置位，传入FALSE表示自动置位。如果为自动置位，则对该事件调用WaitForSingleObject()后会自动调用ResetEvent()使事件变成未触发状态。打个小小比方，手动置位事件相当于教室门，教室门一旦打开（被触发），所以有人都可以进入直到老师去关上教室门（事件变成未触发）。自动置位事件就相当于医院里拍X光的房间门，门打开后只能进入一个人，这个人进去后会将门关上，其它人不能进入除非门重新被打开（事件重新被触发）。

第三个参数表示事件的初始状态，传入TRUR表示已触发。

第四个参数表示事件的名称，传入NULL表示匿名事件。

 

第二个 OpenEvent

函数功能：根据名称获得一个事件句柄。

函数原型：

HANDLEOpenEvent(

 DWORDdwDesiredAccess,

 BOOLbInheritHandle,

 LPCTSTRlpName     //名称

);

函数说明：

第一个参数表示访问权限，对事件一般传入EVENT_ALL_ACCESS。详细解释可以查看MSDN文档。

第二个参数表示事件句柄继承性，一般传入TRUE即可。

第三个参数表示名称，不同进程中的各线程可以通过名称来确保它们访问同一个事件。

 

第三个SetEvent

函数功能：触发事件

函数原型：BOOLSetEvent(HANDLEhEvent);

函数说明：每次触发后，必有一个或多个处于等待状态下的线程变成可调度状态。

 

第四个ResetEvent

函数功能：将事件设为末触发

函数原型：BOOLResetEvent(HANDLEhEvent);

 

最后一个事件的清理与销毁

由于事件是内核对象，因此使用CloseHandle()就可以完成清理与销毁了。

 

在经典多线程问题中设置一个事件和一个关键段。用事件处理主线程与子线程的同步，用关键段来处理各子线程间的互斥。详见代码：

[cpp]  view plain copy

1. #include <stdio.h>  
2. #include <process.h>  
3. #include <windows.h>  
4. long g_nNum;  
5. unsigned int __stdcall Fun(void *pPM);  
6. const int THREAD_NUM = 10;  
7. //事件与关键段  
8. HANDLE  g_hThreadEvent;  
9. CRITICAL_SECTION g_csThreadCode;  
10. int main()  
11. {  
12.     printf("     经典线程同步 事件Event\n");  
13.     printf(" -- by MoreWindows( http://blog.csdn.net/MoreWindows ) --\n\n");  
14.     //初始化事件和关键段 自动置位,初始无触发的匿名事件  
15.     g_hThreadEvent = CreateEvent(NULL, FALSE, FALSE, NULL);   
16.     InitializeCriticalSection(&g_csThreadCode);  
17.   
18.     HANDLE  handle[THREAD_NUM];   
19.     g_nNum = 0;  
20.     int i = 0;  
21.     while (i < THREAD_NUM)   
22.     {  
23.         handle[i] = (HANDLE)_beginthreadex(NULL, 0, Fun, &i, 0, NULL);  
24.         WaitForSingleObject(g_hThreadEvent, INFINITE); //等待事件被触发  
25.         i++;  
26.     }  
27.     WaitForMultipleObjects(THREAD_NUM, handle, TRUE, INFINITE);  
28.   
29.     //销毁事件和关键段  
30.     CloseHandle(g_hThreadEvent);  
31.     DeleteCriticalSection(&g_csThreadCode);  
32.     return 0;  
33. }  
34. unsigned int __stdcall Fun(void *pPM)  
35. {  
36.     int nThreadNum = *(int *)pPM;   
37.     SetEvent(g_hThreadEvent); //触发事件  
38.       
39.     Sleep(50);//some work should to do  
40.       
41.     EnterCriticalSection(&g_csThreadCode);  
42.     g_nNum++;  
43.     Sleep(0);//some work should to do  
44.     printf("线程编号为%d  全局资源值为%d\n", nThreadNum, g_nNum);   
45.     LeaveCriticalSection(&g_csThreadCode);  
46.     return 0;  
47. }  

运行结果如下图：

可以看出来，经典线线程同步问题已经圆满的解决了——线程编号的输出没有重复，说明主线程与子线程达到了同步。全局资源的输出是递增的，说明各子线程已经互斥的访问和输出该全局资源。

 

现在我们知道了如何使用事件，但学习就应该要深入的学习，何况微软给事件还提供了PulseEvent()函数，所以接下来再继续深挖下事件Event，看看它还有什么秘密没。

先来看看这个函数的原形：

第五个PulseEvent

函数功能：将事件触发后立即将事件设置为未触发，相当于触发一个事件脉冲。

函数原型：BOOLPulseEvent(HANDLEhEvent);

函数说明：这是一个不常用的事件函数，此函数相当于SetEvent()后立即调用ResetEvent();此时情况可以分为两种：

1.对于手动置位事件，所有正处于等待状态下线程都变成可调度状态。

2.对于自动置位事件，所有正处于等待状态下线程只有一个变成可调度状态。

此后事件是末触发的。该函数不稳定，因为无法预知在调用PulseEvent ()时哪些线程正处于等待状态。

 

       下面对这个触发一个事件脉冲PulseEvent ()写一个例子，主线程启动7个子线程，其中有5个线程Sleep(10)后对一事件调用等待函数（称为快线程），另有2个线程Sleep(100)后也对该事件调用等待函数（称为慢线程）。主线程启动所有子线程后再Sleep(50)保证有5个快线程都正处于等待状态中。此时若主线程触发一个事件脉冲，那么对于手动置位事件，这5个线程都将顺利执行下去。对于自动置位事件，这5个线程中会有中一个顺利执行下去。而不论手动置位事件还是自动置位事件，那2个慢线程由于Sleep(100)所以会错过事件脉冲，因此慢线程都会进入等待状态而无法顺利执行下去。

代码如下：

[cpp]  view plain copy

1. //使用PluseEvent()函数  
2. #include <stdio.h>  
3. #include <conio.h>  
4. #include <process.h>  
5. #include <windows.h>  
6. HANDLE  g_hThreadEvent;  
7. //快线程  
8. unsigned int __stdcall FastThreadFun(void *pPM)  
9. {  
10.     Sleep(10); //用这个来保证各线程调用等待函数的次序有一定的随机性  
11.     printf("%s 启动\n", (PSTR)pPM);  
12.     WaitForSingleObject(g_hThreadEvent, INFINITE);  
13.     printf("%s 等到事件被触发 顺利结束\n", (PSTR)pPM);  
14.     return 0;  
15. }  
16. //慢线程  
17. unsigned int __stdcall SlowThreadFun(void *pPM)  
18. {  
19.     Sleep(100);  
20.     printf("%s 启动\n", (PSTR)pPM);  
21.     WaitForSingleObject(g_hThreadEvent, INFINITE);  
22.     printf("%s 等到事件被触发 顺利结束\n", (PSTR)pPM);  
23.     return 0;  
24. }  
25. int main()  
26. {  
27.     printf("  使用PluseEvent()函数\n");  
28.     printf(" -- by MoreWindows( http://blog.csdn.net/MoreWindows ) --\n\n");  
29.   
30.     BOOL bManualReset = FALSE;  
31.     //创建事件 第二个参数手动置位TRUE，自动置位FALSE  
32.     g_hThreadEvent = CreateEvent(NULL, bManualReset, FALSE, NULL);  
33.     if (bManualReset == TRUE)  
34.         printf("当前使用手动置位事件\n");  
35.     else  
36.         printf("当前使用自动置位事件\n");  
37.   
38.     char szFastThreadName[5][30] = {"快线程1000", "快线程1001", "快线程1002", "快线程1003", "快线程1004"};  
39.     char szSlowThreadName[2][30] = {"慢线程196", "慢线程197"};  
40.   
41.     int i;  
42.     for (i = 0; i < 5; i++)  
43.         _beginthreadex(NULL, 0, FastThreadFun, szFastThreadName[i], 0, NULL);  
44.     for (i = 0; i < 2; i++)  
45.         _beginthreadex(NULL, 0, SlowThreadFun, szSlowThreadName[i], 0, NULL);  
46.       
47.     Sleep(50); //保证快线程已经全部启动  
48.     printf("现在主线程触发一个事件脉冲 - PulseEvent()\n");  
49.     PulseEvent(g_hThreadEvent);//调用PulseEvent()就相当于同时调用下面二句  
50.     //SetEvent(g_hThreadEvent);  
51.     //ResetEvent(g_hThreadEvent);  
52.       
53.     Sleep(3000);   
54.     printf("时间到，主线程结束运行\n");  
55.     CloseHandle(g_hThreadEvent);  
56.     return 0;  
57. }  

对自动置位事件，运行结果如下：

对手动置位事件，运行结果如下：

 

 

最后总结下事件Event

1．事件是内核对象，事件分为手动置位事件和自动置位事件。事件Event内部它包含一个使用计数（所有内核对象都有），一个布尔值表示是手动置位事件还是自动置位事件，另一个布尔值用来表示事件有无触发。

2．事件可以由SetEvent()来触发，由ResetEvent()来设成未触发。还可以由PulseEvent()来发出一个事件脉冲。

3．事件可以解决线程间同步问题，因此也能解决互斥问题。

 

后面二篇《秒杀多线程第七篇 经典线程同步 互斥量Mutex》和《秒杀多线程第八篇 经典线程同步 信号量Semaphore》将介绍如何使用互斥量和信号量来解决这个经典线程同步问题。欢迎大家继续秒杀多线程之旅。