多线程的那点儿事

最新推荐文章于 2022-01-03 20:50:05 发布
最新推荐文章于 2022-01-03 20:50:05 发布
阅读量2.3k 收藏 2
点赞数
分类专栏： 技术理论 C/C++ 编程语言 其它文章
其它文章 同时被 3 个专栏收录
1407 篇文章 2 订阅
订阅专栏
技术理论
1010 篇文章 11 订阅
订阅专栏
C/C++
831 篇文章 15 订阅
订阅专栏

【 声明：版权所有，欢迎转载，请勿用于商业用途。  联系信箱：feixiaoxing @163.com】


（基础篇） 

 

    多线程编程是现代软件技术中很重要的一个环节。要弄懂多线程，这就要牵涉到多进程？当然，要了解到多进程，就要涉及到操作系统。不过大家也不要紧张，听我慢慢道来。这其中的环节其实并不复杂。

    （1）单CPU下的多线程

     在没有出现多核CPU之前，我们的计算资源是唯一的。如果系统中有多个任务要处理的话，那么就需要按照某种规则依次调度这些任务进行处理。什么规则呢？可以是一些简单的调度方法，比如说

    1）按照优先级调度

    2）按照FIFO调度

    3）按照时间片调度等等

    当然，除了CPU资源之外，系统中还有一些其他的资源需要共享，比如说内存、文件、端口、socket等。既然前面说到系统中的资源是有限的，那么获取这些资源的最小单元体是什么呢，其实就是进程。

    举个例子来说，在linux上面每一个享有资源的个体称为task_struct，实际上和我们说的进程是一样的。我们可以看看task_struct（linux 0.11代码）都包括哪些内容，

[cpp] view plain copy print ?
  1. struct task_struct {  
  2. /* these are hardcoded - don't touch */  
  3.     long state; /* -1 unrunnable, 0 runnable, >0 stopped */  
  4.     long counter;  
  5.     long priority;  
  6.     long signal;  
  7.     struct sigaction sigaction[32];  
  8.     long blocked;   /* bitmap of masked signals */  
  9. /* various fields */  
  10.     int exit_code;  
  11.     unsigned long start_code,end_code,end_data,brk,start_stack;  
  12.     long pid,father,pgrp,session,leader;  
  13.     unsigned short uid,euid,suid;  
  14.     unsigned short gid,egid,sgid;  
  15.     long alarm;  
  16.     long utime,stime,cutime,cstime,start_time;  
  17.     unsigned short used_math;  
  18. /* file system info */  
  19.     int tty;        /* -1 if no tty, so it must be signed */  
  20.     unsigned short umask;  
  21.     struct m_inode * pwd;  
  22.     struct m_inode * root;  
  23.     struct m_inode * executable;  
  24.     unsigned long close_on_exec;  
  25.     struct file * filp[NR_OPEN];  
  26. /* ldt for this task 0 - zero 1 - cs 2 - ds&ss */  
  27.     struct desc_struct ldt[3];  
  28. /* tss for this task */  
  29.     struct tss_struct tss;  
  30. };  
	struct task_struct {
	/* these are hardcoded - don't touch */
		long state;	/* -1 unrunnable, 0 runnable, >0 stopped */
		long counter;
		long priority;
		long signal;
		struct sigaction sigaction[32];
		long blocked;	/* bitmap of masked signals */
	/* various fields */
		int exit_code;
		unsigned long start_code,end_code,end_data,brk,start_stack;
		long pid,father,pgrp,session,leader;
		unsigned short uid,euid,suid;
		unsigned short gid,egid,sgid;
		long alarm;
		long utime,stime,cutime,cstime,start_time;
		unsigned short used_math;
	/* file system info */
		int tty;		/* -1 if no tty, so it must be signed */
		unsigned short umask;
		struct m_inode * pwd;
		struct m_inode * root;
		struct m_inode * executable;
		unsigned long close_on_exec;
		struct file * filp[NR_OPEN];
	/* ldt for this task 0 - zero 1 - cs 2 - ds&ss */
		struct desc_struct ldt[3];
	/* tss for this task */
		struct tss_struct tss;
	};

    每一个task都有自己的pid，在系统中资源的分配都是按照pid进行处理的。这也就说明，进程确实是资源分配的主体。

    这时候，可能有朋友会问了，既然task_struct是资源分配的主体，那为什么又出来thread？为什么系统调度的时候是按照thread调度，而不是按照进程调度呢？原因其实很简单，进程之间的数据沟通非常麻烦，因为我们之所以把这些进程分开，不正是希望它们之间不要相互影响嘛。

    假设是两个进程之间数据传输，那么需要如果需要对共享数据进行访问需要哪些步骤呢，

    1）创建共享内存

    2）访问共享内存->系统调用->读取数据

    3）写入共享内存->系统调用->写入数据

    要是写个代码，大家可能就更明白了，

[cpp] view plain copy print ?
  1. #include <unistd.h>   
  2. #include <stdio.h>   
  3.   
  4. int value = 10;  
  5.   
  6. int main(int argc, char* argv[])  
  7. {  
  8.     int pid = fork();  
  9.     if(!pid){  
  10.         Value = 12;  
  11.         return 0;  
  12.     }  
  13.     printf("value = %d\n", value);  
  14.     return 1;  
  15. }  
	#include <unistd.h>
	#include <stdio.h>
	
	int value = 10;
	
	int main(int argc, char* argv[])
	{
	    int pid = fork();
	    if(!pid){
	        Value = 12;
	        return 0;
	    }
	    printf("value = %d\n", value);
	    return 1;
	}

    上面的代码是一个创建子进程的代码，我们发现打印的value数值还是10。尽管中间创建了子进程，修改了value的数值，但是我们发现打印下来的数值并没有发生改变，这就说明了不同的进程之间内存上是不共享的。

    那么，如果修改成thread有什么好处呢？其实最大的好处就是每个thread除了享受单独cpu调度的机会，还能共享每个进程下的所有资源。要是调度的单位是进程，那么每个进程只能干一件事情，但是进程之间是需要相互交互数据的，而进程之间的数据都需要系统调用才能应用，这在无形之中就降低了数据的处理效率。


    （2）多核CPU下的多线程

    没有出现多核之前，我们的CPU实际上是按照某种规则对线程依次进行调度的。在某一个特定的时刻，CPU执行的还是某一个特定的线程。然而，现在有了多核CPU，一切变得不一样了，因为在某一时刻很有可能确实是n个任务在n个核上运行。我们可以编写一个简单的open mp测试一下，如果还是一个核，运行的时间就应该是一样的。

[cpp] view plain copy print ?
  1. #include <omp.h>   
  2. #define MAX_VALUE 10000000   
  3.   
  4. double _test(int value)  
  5. {  
  6.     int index;  
  7.     double result;  
  8.   
  9.     result = 0.0;  
  10.     for(index = value + 1; index < MAX_VALUE; index +=2 )  
  11.         result += 1.0 / index;  
  12.   
  13.     return result;  
  14. }  
  15.   
  16. void test()  
  17. {  
  18.     int index;  
  19.     int time1;  
  20.     int time2;  
  21.     double value1,value2;  
  22.     double result[2];  
  23.   
  24.     time1 = 0;  
  25.     time2 = 0;  
  26.   
  27.     value1 = 0.0;  
  28.     time1 = GetTickCount();  
  29.     for(index = 1; index < MAX_VALUE; index ++)  
  30.         value1 += 1.0 / index;  
  31.   
  32.     time1 = GetTickCount() - time1;  
  33.   
  34.     value2 = 0.0;  
  35.     memset(result , 0, sizeof(double) * 2);  
  36.     time2 = GetTickCount();  
  37.   
  38. #pragma omp parallel for   
  39.     for(index = 0; index < 2; index++)  
  40.         result[index] = _test(index);  
  41.   
  42.     value2 = result[0] + result[1];  
  43.     time2 = GetTickCount() - time2;  
  44.   
  45.     printf("time1 = %d,time2 = %d\n",time1,time2);  
  46.     return;  
  47. }  
#include <omp.h>
#define MAX_VALUE 10000000

double _test(int value)
{
	int index;
	double result;

	result = 0.0;
	for(index = value + 1; index < MAX_VALUE; index +=2 )
		result += 1.0 / index;

	return result;
}

void test()
{
	int index;
	int time1;
	int time2;
	double value1,value2;
	double result[2];

    time1 = 0;
	time2 = 0;

	value1 = 0.0;
	time1 = GetTickCount();
	for(index = 1; index < MAX_VALUE; index ++)
		value1 += 1.0 / index;

	time1 = GetTickCount() - time1;

	value2 = 0.0;
	memset(result , 0, sizeof(double) * 2);
	time2 = GetTickCount();

#pragma omp parallel for
	for(index = 0; index < 2; index++)
		result[index] = _test(index);

	value2 = result[0] + result[1];
	time2 = GetTickCount() - time2;

	printf("time1 = %d,time2 = %d\n",time1,time2);
	return;
}

    （3）多线程编程

为什么要多线程编程呢？这其中的原因很多，我们可以举例解决

    1）有的是为了提高运行的速度，比如多核cpu下的多线程

    2）有的是为了提高资源的利用率，比如在网络环境下下载资源时，时延常常很高，我们可以通过不同的thread从不同的地方获取资源，这样可以提高效率

    3）有的为了提供更好的服务，比如说是服务器

    4）其他需要多线程编程的地方等等



（之数据同步） 

多线程创建其实十分简单，在windows系统下面有很多函数可以创建多线程，比如说_beginthread。我们就可以利用它为我们编写一段简单的多线程代码，

[cpp] view plain copy print ?
  1. #include <windows.h>   
  2. #include <process.h>   
  3. #include <stdio.h>   
  4.   
  5. unsigned int value = 0;  
  6.   
  7. void print(void* argv)  
  8. {  
  9.     while(1){  
  10.         printf("&value = %x, value = %d\n", &value, value);  
  11.         value ++;  
  12.         Sleep(1000);  
  13.     }  
  14. }  
  15.   
  16. int main()  
  17. {  
  18.     _beginthread( print, 0, NULL );  
  19.     _beginthread( print, 0, NULL);  
  20.   
  21.     while(1)   
  22.         Sleep(0);  
  23.   
  24.     return 1;  
  25. }  
	#include <windows.h>
	#include <process.h>
	#include <stdio.h>
	
	unsigned int value = 0;
	
	void print(void* argv)
	{
		while(1){
			printf("&value = %x, value = %d\n", &value, value);
			value ++;
			Sleep(1000);
		}
	}
	
	int main()
	{
	    _beginthread( print, 0, NULL );
		_beginthread( print, 0, NULL);
	
		while(1) 
			Sleep(0);
	
		return 1;
	}

    注意，在VC上面编译的时候，需要打开/MD开关。具体操作为，【project】->【setting】->【c/c++】->Category【Code Generation】->【Use run-time library】->【Debug Multithreaded】即可。

    通过上面的示例，我们看到作为共享变量的value事实上是可以被所有的线程访问的。这就是线程数据同步的最大优势——方便，直接。因为线程之间除了堆栈空间不一样之外，代码段和数据段都是在一个空间里面的。所以，线程想访问公共数据，就可以访问公共数据，没有任何的限制。

    当然，事物都有其两面性。这种对公共资源的访问模式也会导致一些问题。什么问题呢？我们看了就知道了。

    现在假设有一个池塘，我们雇两个人来喂鱼。两个人不停地对池塘里面的鱼进行喂食。我们规定在一个人喂鱼的时候，另外一个人不需要再喂鱼，否则鱼一次喂两回就要撑死了。为此，我们安装了一个牌子作为警示。如果一个人在喂鱼，他会把牌子设置为FALSE，那么另外一个人看到这个牌子，就不会继续喂鱼了。等到这个人喂完后，他再把牌子继续设置为TRUE。

    如果我们需要把这个故事写成代码，那么怎么写呢？朋友们试试看，

[cpp] view plain copy print ?
  1. while(1){  
  2.     if( flag == true){  
  3.         flag = false;  
  4.         do_give_fish_food();  
  5.         flag = true;  
  6.     }  
  7.   
  8.     Sleep(0);  
  9. }  
	while(1){
		if( flag == true){
	        flag = false;
			do_give_fish_food();
			flag = true;
		}
	
		Sleep(0);
	}

    上面的代码看上去没有问题了，但是大家看看代码的汇编代码，看看是不是存在隐患。因为还会出现两个人同时喂食的情况，

[cpp] view plain copy print ?
  1. 23:       while(1){  
  2. 004010E8   mov         eax,1  
  3. 004010ED   test        eax,eax  
  4. 004010EF   je          do_action+56h (00401126)  
  5. 24:           if( flag == true){  
  6. 004010F1   cmp         dword ptr [flag (00433e04)],1  
  7. 004010F8   jne         do_action+43h (00401113)  
  8. 25:               flag = false;  
  9. 004010FA   mov         dword ptr [flag (00433e04)],0  
  10. 26:               do_give_fish_food();  
  11. 00401104   call        @ILT+15(do_give_fish_food) (00401014)  
  12. 27:               flag = true;  
  13. 00401109   mov         dword ptr [flag (00433e04)],1  
  14. 28:           }  
  15. 29:  
  16. 30:           Sleep(0);  
  17. 00401113   mov         esi,esp  
  18. 00401115   push        0  
  19. 00401117   call        dword ptr [__imp__Sleep@4 (004361c4)]  
  20. 0040111D   cmp         esi,esp  
  21. 0040111F   call        __chkesp (004011e0)  
  22. 31:       }  
  23. 00401124   jmp         do_action+18h (004010e8)  
  24. 32:   }  
23:       while(1){
004010E8   mov         eax,1
004010ED   test        eax,eax
004010EF   je          do_action+56h (00401126)
24:           if( flag == true){
004010F1   cmp         dword ptr [flag (00433e04)],1
004010F8   jne         do_action+43h (00401113)
25:               flag = false;
004010FA   mov         dword ptr [flag (00433e04)],0
26:               do_give_fish_food();
00401104   call        @ILT+15(do_give_fish_food) (00401014)
27:               flag = true;
00401109   mov         dword ptr [flag (00433e04)],1
28:           }
29:
30:           Sleep(0);
00401113   mov         esi,esp
00401115   push        0
00401117   call        dword ptr [__imp__Sleep@4 (004361c4)]
0040111D   cmp         esi,esp
0040111F   call        __chkesp (004011e0)
31:       }
00401124   jmp         do_action+18h (004010e8)
32:   }

    我们此时假设有两个线程a和b在不停地进行判断和喂食操作。设置当前flag = true，此时线程a执行到004010F8处时，判断鱼还没有喂食，正准备执行指令004010F8，但是还没有来得及对falg进行设置，此时出现了线程调度。线程b运行到004010F8时，发现当前没有人喂食，所以执行喂食操作。等到b线程喂食结束，运行到00401113的时候，此时又出现了调度。线程a有继续运行，因为之前已经判断了当前还没有喂食，所以线程a继续进行了喂食了操作。所以，可怜的鱼，这一次就连续经历了两次喂食操作，估计有一部分鱼要撑死了。

    当然鱼在这里之所以会出现撑死的情况，主要是因为line 24和line 25之间出现了系统调度。所以，我们在编写程序的时候必须有一个牢固的思想意识，如果缺少必须要的手段，程序可以任何时刻任何地点被调度，那此时公共数据的计算就会出现错误。

    那么有没有方法避免这种情况的发生呢？当然有。朋友们可以继续关注下面的博客。




（之数据互斥） 

    在多线程存在的环境中，除了堆栈中的临时数据之外，所有的数据都是共享的。如果我们需要线程之间正确地运行，那么务必需要保证公共数据的执行和计算是正确的。简单一点说，就是保证数据在执行的时候必须是互斥的。否则，如果两个或者多个线程在同一时刻对数据进行了操作，那么后果是不可想象的。

    也许有的朋友会说，不光数据需要保护，代码也需要保护。提出这个观点的朋友只看到了数据访问互斥的表象。在程序的运行空间里面，什么最重要的呢？代码吗？当然不是。代码只是为了数据的访问存在的。数据才是我们一切工作的出发点和落脚点。

    那么，有什么办法可以保证在某一时刻只有一个线程对数据进行操作呢？四个基本方法：

    （1）关中断

    （2）数学互斥方法

    （3）操作系统提供的互斥方法

    （4）cpu原子操作

    为了让大家可以对这四种方法有详细的认识，我们可以进行详细的介绍。

  

    （1）关中断

    要让数据在某一时刻只被一个线程访问，方法之一就是停止线程调度就可以了。那么怎样停止线程调度呢？那么关掉时钟中断就可以了啊。在X86里面的确存在这样的两个指令，

[cpp] view plain copy print ?
  1. #include <stdio.h>   
  2.   
  3. int main()  
  4. {  
  5.     __asm{  
  6.         cli  
  7.         sti  
  8.     }  
  9.     return 1;  
  10. }  
#include <stdio.h>

int main()
{
	__asm{
		cli
		sti
	}
	return 1;
}

    其中cli是关中断，sti是开中断。这段代码没有什么问题，可以编过，当然也可以生成执行文件。但是在执行的时候会出现一个异常告警：Unhandled exception in test.exe: 0xC0000096:  Privileged Instruction。告警已经说的很清楚了，这是一个特权指令。只有系统或者内核本身才可以使用这个指令。

    不过，大家也可以想象一下。因为平常我们编写的程序都是应用级别的程序，要是每个程序都是用这些代码，那不乱了套了。比如说，你不小心安装一个低质量的软件，说不定什么时候把你的中断关了，这样你的网络就断了，你的输入就没有回应了，你的音乐什么都没有了，这样的环境你受的了吗？应用层的软件是千差万别的，软件的水平也是参差不齐的，所以系统不可能相信任何一个私有软件，它相信的只是它自己。

 

    （2）数学方法

    假设有两个线程（a、b）正要对一个共享数据进行访问，那么怎么做到他们之间的互斥的呢？其实我们可以这么做，

[cpp] view plain copy print ?
  1. unsigned int flag[2] = {0};  
  2. unsigned int turn = 0;  
  3.   
  4. void process(unsigned int index)  
  5. {  
  6.     flag[index] = 1;  
  7.     turn =  index;  
  8.   
  9.     while(flag[1 - index] && (turn ==  index));  
  10.     do_something();  
  11.     flag[index] = 0;  
  12. }  
unsigned int flag[2] = {0};
unsigned int turn = 0;

void process(unsigned int index)
{
	flag[index] = 1;
	turn =  index;

	while(flag[1 - index] && (turn ==  index));
	do_something();
	flag[index] = 0;
}

    其实，学过操作系统的朋友都知道，上面的算法其实就是Peterson算法，可惜它只能用于两个线程的数据互斥。当然，这个算法还可以推广到更多线程之间的互斥，那就是bakery算法。但是数学算法有两个缺点：

    a）占有空间多，两个线程就要flag占两个单位空间，那么n个线程就要n个flag空间，

    b）代码编写复杂，考虑的情况比较复杂

 

    （3）系统提供的互斥算法

    系统提供的互斥算法其实是我们平时开发中用的最多的互斥工具。就拿windows来说，关于互斥的工具就有临界区、互斥量、信号量等等。这类算法有一个特点，那就是都是依据系统提高的互斥资源，那么系统又是怎么完成这些功能的呢？其实也不难。

    系统加锁过程，

[cpp] view plain copy print ?
  1. void Lock(HANDLE hLock)  
  2. {  
  3.     __asm {cli};  
  4.   
  5.     while(1){  
  6.         if(/* 锁可用*/){  
  7.             /* 设定标志，表明当前锁已被占用 */  
  8.             __asm {sti};  
  9.             return;  
  10.         }  
  11.   
  12.         __asm{sti};  
  13.         schedule();  
  14.         __asm{cli};  
  15.     }  
  16. }  
void Lock(HANDLE hLock)
{
	__asm {cli};

	while(1){
		if(/* 锁可用*/){
			/* 设定标志，表明当前锁已被占用 */
			__asm {sti};
			return;
		}

		__asm{sti};
		schedule();
		__asm{cli};
	}
}

    系统解锁过程，

[cpp] view plain copy print ?
  1. void UnLock(HANDLE hLock)  
  2. {  
  3.     __asm {cli};  
  4.     /* 设定标志， 当前锁可用 */  
  5.     __asm{sti};  
  6. }  
void UnLock(HANDLE hLock)
{
	__asm {cli};
	/* 设定标志， 当前锁可用 */
	__asm{sti};
}

    上面其实讨论的就是一种最简单的系统锁情况。中间没有涉及到就绪线程的压入和弹出过程，没有涉及到资源个数的问题，所以不是很复杂。朋友们仔细看看，应该都可以明白代码表达的是什么意思。

 

    （4）CPU的原子操作
    因为在多线程操作当中，有很大一部分是比较、自增、自减等简单操作。因为需要互斥的代码很少，所以使用互斥量、信号量并不合算。因此，CPU厂商为了开发的方便，把一些常用的指令设计成了原子指令，在windows上面也被称为原子锁，常用的原子操作函数有

[cpp] view plain copy print ?
  1. InterLockedAdd  
  2.   
  3. InterLockedExchange  
  4.   
  5. InterLockedCompareExchange  
  6.   
  7. InterLockedIncrement  
  8.   
  9. InterLockedDecrement  
  10.   
  11. InterLockedAnd  
  12.   
  13. InterLockedOr  
InterLockedAdd

InterLockedExchange

InterLockedCompareExchange

InterLockedIncrement

InterLockedDecrement

InterLockedAnd

InterLockedOr


 

 


（之自旋锁） 

 自旋锁是SMP中经常使用到的一个锁。所谓的smp，就是对称多处理器的意思。在工业用的pcb板上面，特别是服务器上面，一个pcb板有多个cpu是很正常的事情。这些cpu相互之间是独立运行的，每一个cpu均有自己的调度队列。然而，这些cpu在内存空间上是共享的。举个例子说，假设有一个数据value = 10，那么这个数据可以被所有的cpu访问。这就是共享内存的本质意义。

    我们可以看一段Linux 下的的自旋锁代码（kernel 2.6.23，asm-i386/spinlock.h），就可有清晰的认识了，

[cpp] view plain copy print ?
  1. static inline void __raw_spin_lock(raw_spinlock_t *lock)  
  2. {  
  3.     asm volatile("\n1:\t"  
  4.              LOCK_PREFIX " ; decb %0\n\t"  
  5.              "jns 3f\n"  
  6.              "2:\t"  
  7.              "rep;nop\n\t"  
  8.              "cmpb $0,%0\n\t"  
  9.              "jle 2b\n\t"  
  10.              "jmp 1b\n"  
  11.              "3:\n\t"  
  12.              : "+m" (lock->slock) : : "memory");  
  13. }  
static inline void __raw_spin_lock(raw_spinlock_t *lock)
{
	asm volatile("\n1:\t"
		     LOCK_PREFIX " ; decb %0\n\t"
		     "jns 3f\n"
		     "2:\t"
		     "rep;nop\n\t"
		     "cmpb $0,%0\n\t"
		     "jle 2b\n\t"
		     "jmp 1b\n"
		     "3:\n\t"
		     : "+m" (lock->slock) : : "memory");
}
上面这段代码是怎么做到自旋锁的呢？我们可以一句一句看看，


line  4: 对lock->slock自减，这个操作是互斥的，LOCK_PREFIX保证了此刻只能有一个CPU访问内存
line  5: 判断lock->slock是否为非负数，如果是跳转到3，即获得自旋锁
line  6: 位置符
line  7: lock->slock此时为负数，说明已经被其他cpu抢占了，cpu休息一会，相当于pause指令
line  8: 继续将lock->slock和0比较，
line  9: 判断lock->slock是否小于等于0，如果判断为真，跳转到2，继续休息
line 10: 此时lock->slock已经大于0，可以继续尝试抢占了，跳转到1
line 11: 位置符 
  
    上面的操作，除了第4句是cpu互斥操作，其他都不是。所以，我们发现，在cpu之间寻求互斥访问的时候，在某一时刻只有一个内存访问权限。所以，如果其他的cpu之间没有获得访问权限，就会不断地查看当前是否可以再次申请自旋锁了。这个过程中间不会停歇，除非获得访问的权限为止。


总结：
   1）在smp上自旋锁是多cpu互斥访问的基础
   2）因为自旋锁是自旋等待的，所以处于临界区的代码应尽可能短
   3）上面的LOCK_PREFIX，在x86下面其实就是“lock”，gcc下可以编过，朋友们可以自己试试

（之windows锁） 


    在windows系统中，系统本身为我们提供了很多锁。通过这些锁的使用，一方面可以加强我们对锁的认识，另外一方面可以提高代码的性能和健壮性。常用的锁以下四种：临界区，互斥量，信号量，event。

    

    （1）临界区

    临界区是最简单的一种锁。基本的临界区操作有，

[cpp] view plain copy print ?
  1. InitializeCriticalSection  
  2. EnterCriticalSection  
  3. LeaveCriticalSection  
  4. DeleteCriticalSection  
    InitializeCriticalSection
    EnterCriticalSection
    LeaveCriticalSection
    DeleteCriticalSection
    如果想要对数据进行互斥操作的话，也很简单，这样做就可以了，
[cpp] view plain copy print ?
  1. EnterCriticalSection(/*...*/)  
  2.     do_something();  
  3. LeaveCriticalSection(/*...*/)  
    EnterCriticalSection(/*...*/)
        do_something();
    LeaveCriticalSection(/*...*/)

     （2）互斥锁
    互斥锁也是一种锁。和临界区不同的是，它可以被不同进程使用，因为它有名字。同时，获取锁和释放锁的线程必须是同一个线程。常用的互斥锁操作有

[cpp] view plain copy print ?
  1. CreateMutex  
  2. OpenMutex  
  3. ReleaseMutex  
    CreateMutex
    OpenMutex
    ReleaseMutex
    那么，怎么用互斥锁进行数据的访问呢，其实不难。
[cpp] view plain copy print ?
  1. WaitForSingleObject(/*...*/);  
  2.     do_something();  
  3. ReleaseMutex(/*...*/);  
    WaitForSingleObject(/*...*/);
        do_something();
    ReleaseMutex(/*...*/);

     （3）信号量
    信号量是使用的最多的一种锁结果，也是最方便的一种锁。围绕着信号量，人们提出了很多数据互斥访问的方案，pv操作就是其中的一种。如果说互斥锁只能对单个资源进行保护，那么信号量可以对多个资源进行保护。同时信号量在解锁的时候，可以被另外一个thread进行解锁操作。目前，常用的信号量操作有，

[cpp] view plain copy print ?
  1. CreateSemaphore  
  2. OpenSemaphore  
  3. ReleaseSemaphore  
    CreateSemaphore
    OpenSemaphore
    ReleaseSemaphore
    信号量的使用和互斥锁差不多。关键是信号量在初始化的时候需要明确当前资源的数量和信号量的初始状态是什么，

[cpp] view plain copy print ?
  1. WaitForSingleObject(/*...*/);  
  2.     do_something();  
  3. ReleaseSemaphore(/*...*/);  
    WaitForSingleObject(/*...*/);
        do_something();
    ReleaseSemaphore(/*...*/);

     （4）event对象
    event对象是windows下面很有趣的一种锁结果。从某种意义上说，它和互斥锁很相近，但是又不一样。因为在thread获得锁的使用权之前，常常需要main线程调用SetEvent设置一把才可以。关键是，在thread结束之前，我们也不清楚当前thread获得event之后执行到哪了。所以使用起来，要特别小心。常用的event操作有，

[cpp] view plain copy print ?
  1. CreateEvent  
  2. OpenEvent  
  3. PulseEvent  
  4. ResetEvent  
  5. SetEvent  
    CreateEvent
    OpenEvent
    PulseEvent
    ResetEvent
    SetEvent
    我们对event的使用习惯于分成main thread和normal thread使用。main thread负责event的设置和操作，而normal thread负责event的等待操作。在CreateEvent的时候，要务必考虑清楚event的初始状态和基本属性。
    对于main thread，应该这么做，
[cpp] view plain copy print ?
  1. CreateEvent(/*...*/);  
  2. SetEvent(/*...*/);  
  3. WaitForMultiObjects(hThread, /*...*/);  
  4. CloseHandle(/*...*/);  
    CreateEvent(/*...*/);
    SetEvent(/*...*/);
    WaitForMultiObjects(hThread, /*...*/);
    CloseHandle(/*...*/);

    对于normal thread来说，操作比较简单，

[cpp] view plain copy print ?
  1. while(1){  
  2.     WaitForSingleObject(/*...*/);  
  3.   
  4.     /*...*/  
  5. }  
    while(1){
        WaitForSingleObject(/*...*/);

        /*...*/
    }

总结：
    （1）关于 临界区、 互斥区、 信号量、 event在msdn上均有示例代码
    （2）一般来说，使用频率上信号量 > 互斥区 > 临界区 > 事件对象
    （3）信号量可以实现其他三种锁的功能，学习上应有所侧重
    （4）纸上得来终觉浅，多实践才能掌握它们之间的区别



（之C++锁） 

  编写程序不容易，编写多线程的程序更不容易。相信编写过多线程的程序都应该有这样的一个痛苦过程，什么样的情况呢？朋友们应该看一下代码就明白了，

[cpp] view plain copy print ?
  1. void data_process()  
  2. {  
  3.     EnterCriticalSection();  
  4.     
  5.     if(/* error happens */)  
  6.     {  
  7.         LeaveCriticalSection();  
  8.         return;  
  9.     }  
  10.   
  11.     if(/* other error happens */)  
  12.     {  
  13.         return;  
  14.     }  
  15.   
  16.     LeaveCriticalSection();  
  17. }  
void data_process()
{
    EnterCriticalSection();
  
    if(/* error happens */)
    {
        LeaveCriticalSection();
        return;
    }

    if(/* other error happens */)
    {
        return;
    }

    LeaveCriticalSection();
}
    上面的代码说明了一种情形。这种多线程的互斥情况在代码编写过程中是经常遇到的。所以，每次对共享数据进行操作时，都需要对数据进行EnterCriticalSection和LeaveCriticalSection的操作。但是，这中间也不是一帆风顺的。很有可能你会遇到各种各样的错误。那么，这时候你的程序就需要跳出去了。可能一开始遇到error的时候，你还记得需要退出临界区。但是，如果错误多了，你未必记得还有这个操作了。这一错就完了，别的线程就没有机会获取这个锁了。
    那么，有没有可能利用C++的特性，自动处理这种情况呢？还真有。我们看看下面这个代码，
[cpp] view plain copy print ?
  1. class CLock  
  2. {  
  3.     CRITICAL_SECTION& cs;  
  4.   
  5. public:  
  6.     CLock(CRITICAL_SECTION& lock):cs(lock){  
  7.         EnterCriticalSection(&cs);  
  8.     }  
  9.   
  10.     ~CLock() {  
  11.         LeaveCriticalSection(&cs);  
  12.     }  
  13. }  
  14.   
  15. class Process  
  16. {  
  17.     CRITICAL_SECTION cs;  
  18.     /* other data */  
  19.   
  20. public:  
  21.     Process(){  
  22.         InitializeCriticalSection(&cs);  
  23.     }  
  24.   
  25.     ~Process() {DeleteCriticalSection(&cs);}  
  26.   
  27.     void data_process(){  
  28.         CLock lock(cs);  
  29.   
  30.         if(/* error happens */){  
  31.             return;  
  32.         }  
  33.   
  34.         return;  
  35.     }  
  36. }  
class CLock
{
    CRITICAL_SECTION& cs;

public:
    CLock(CRITICAL_SECTION& lock):cs(lock){
        EnterCriticalSection(&cs);
    }

    ~CLock() {
        LeaveCriticalSection(&cs);
    }
}

class Process
{
    CRITICAL_SECTION cs;
    /* other data */

public:
    Process(){
        InitializeCriticalSection(&cs);
    }

    ~Process() {DeleteCriticalSection(&cs);}

    void data_process(){
        CLock lock(cs);

        if(/* error happens */){
            return;
        }

        return;
    }
}
    C++的一个重要特点就是，不管函数什么时候退出，系统都会自动调用类的析构函数。在Process类的data_process函数中，，函数在开始就创建了一个CLock类。那么，在创建这个类的时候，其实就开始了临界区的pk。那么一旦进入到临界区当中，在error中能不能及时退出临界区呢？此时，c++析构函数的优势出现了。因为不管错误什么时候出现，在函数退出之前，系统都会帮我们善后。什么善后呢？就是系统会调用CLock的析构函数，也就是退出临界区。这样，我们的目的就达到了。
    其实，这就是一个c++的trick。

（之原子锁） 

   原子锁是多线程编程中的一个特色。然而，在平时的软件编写中，原子锁的使用并不是很多。这其中原因很多，我想主要有两个方面。第一，关于原子锁这方面的内容介绍的比较少；第二，人们在编程上面习惯于已有的方案，如果没有特别的需求，不过贸然修改已存在的代码。毕竟对很多人来说，不求有功，但求无过。保持当前代码的稳定性还是很重要的。  
    其实，早在《 多线程数据互斥》这篇博客中，我们就已经介绍过原子锁。本篇博客主要讨论的就是原子锁怎么使用。中间的一些用法只是我个人的一些经验，希望能够抛砖引玉，多听听大家的想法。

    （1）查找函数中原子锁    

    在一些函数当中，有的时候我们需要对满足某种特性的数据进行查找。在传统的单核CPU上，优化的空间比较有限。但是，现在多核CPU已经成了主流配置。所以我们完全可以把这些查找工作分成几个子函数分在几个核上面并行运算。但是，这中间就会涉及到一个问题，那就是对公共数据的访问。传统的访问方式，应该是这样的，

[cpp] view plain copy print ?
  1. unsigned int count = 0;  
  2.   
  3. int find_data_process()  
  4. {  
  5.     if(/* data meets our standards */){  
  6.          EnterCriticalSection(&cs);  
  7.          count ++;  
  8.          LeaveCriticalSection(&cs);           
  9.     }  
  10. }  
unsigned int count = 0;

int find_data_process()
{
    if(/* data meets our standards */){
         EnterCriticalSection(&cs);
         count ++;
         LeaveCriticalSection(&cs);         
    }
}

    我们看到代码中间使用到了锁，那么势必会涉及到系统调用和函数调度。所以，在执行效率上会大打折扣。那么如果使用原子锁呢？

[cpp] view plain copy print ?
  1. unsigned int count = 0;  
  2.   
  3. int find_data_process()  
  4. {  
  5.     if(/* data meets our standards */){  
  6.         InterLockedIncrement(&count);  
  7.     }  
  8. }  
unsigned int count = 0;

int find_data_process()
{
    if(/* data meets our standards */){
        InterLockedIncrement(&count);
    }
}

    有兴趣的朋友可以做这样一道题目，查看0～0xFFFFFFFF上有多少数可以被3整除？大家也可以验证一下用原子锁代替临界区之后，代码的效率究竟可以提高多少。关于多核多线程的编程，朋友们可以参考《多线程基础篇》这篇博客。


    （2）代码段中的原子锁
    上面的范例只是介绍了统计功能中的原子锁。那么怎么用原子锁代替传统的系统锁呢？比如说，假设原来的数据访问是这样的，

[cpp] view plain copy print ?
  1. void data_process()  
  2. {  
  3.     EnterCriticalSection(&cs);  
  4.     do_something();  
  5.     LeaveCriticalSection(&cs);     
  6. }  
void data_process()
{
    EnterCriticalSection(&cs);
    do_something();
    LeaveCriticalSection(&cs);   
}
    如果改成原子锁呢，会是什么样的呢？
[cpp] view plain copy print ?
  1. unsigned int lock = 0;  
  2.   
  3. void data_process()  
  4. {  
  5.     while(1 == InterLockedCompareExchange(&lock, 1, 0));  
  6.     do_something();  
  7.     lock = 0;      
  8. }  
unsigned int lock = 0;

void data_process()
{
    while(1 == InterLockedCompareExchange(&lock, 1, 0));
    do_something();
    lock = 0;    
}

    这里用原子锁代替普通的系统锁，完成的功能其实是一样的。那么这中间有什么区别呢？其实，关键要看do_something要执行多久。打个比方来说，现在我们去买包子，但是买包子的人很多。那怎么办呢？有两个选择，如果卖包子的人手脚麻利，服务一个顾客只要10秒钟,那么即使前面排队的有50个人，我们只要等7、8分钟就可以，这点等的时间还是值得的；但是如果不幸这个卖包子的老板服务一个顾客要1分钟，那就悲催了，假使前面有50个人，那我们就要等50多分钟了。50分钟对我们来说可是不短的一个时间，我们完全可以利用这个时间去买点水果，交交水电费什么的，过了这个时间点再来买包子也不迟。


    和上面的例子一样，忙等的方法就是原子锁，过一会再来的方法就是哪个传统的系统锁。用哪个，就看这个do_something的时间值不值得我们等待了。



（之读写锁） 

     在编写多线程的时候，有一种情况是十分常见的。那就是，有些公共数据修改的机会比较少。相比较改写，它们读的机会反而高的多。通常而言，在读的过程中，往往伴随着查找的操作，中间耗时很长。给这种代码段加锁，会极大地降低我们程序的效率。那么有没有一种方法，可以专门处理这种多读少写的情况呢？
    有，那就是读写锁。

    （1）首先，我们定义一下基本的数据结构。

[cpp] view plain copy print ?
  1. typedef struct _RWLock  
  2. {  
  3.     int count;  
  4.     int state;  
  5.     HANDLE hRead;  
  6.     HANDLE hWrite;  
  7. }RWLock;     
typedef struct _RWLock
{
    int count;
    int state;
    HANDLE hRead;
    HANDLE hWrite;
}RWLock;
    同时，为了判断当前的锁是处于读状态，还是写状态，我们要定义一个枚举量，
[cpp] view plain copy print ?
  1. typedef enum  
  2. {  
  3.     STATE_EMPTY = 0,  
  4.     STATE_READ,  
  5.     STATE_WRITE  
  6. };  
typedef enum
{
    STATE_EMPTY = 0,
    STATE_READ,
    STATE_WRITE
};
     （2）初始化数据结构

[cpp] view plain copy print ?
  1. RWLock* create_read_write_lock(HANDLE hRead, HANDLE hWrite)  
  2. {  
  3.     RWLock* pRwLock = NULL;  
  4.   
  5.     assert(NULL != hRead && NULL != hWrite);  
  6.     pRwLock = (RWLock*)malloc(sizeof(RWLock));  
  7.     
  8.     pRwLock->hRead = hRead;  
  9.     pRwLock->hWrite = hWrite;  
  10.     pRwLock->count = 0;  
  11.     pRwLock->state = STATE_EMPTY;  
  12.     return pRwLock;  
  13. }  
RWLock* create_read_write_lock(HANDLE hRead, HANDLE hWrite)
{
    RWLock* pRwLock = NULL;

    assert(NULL != hRead && NULL != hWrite);
    pRwLock = (RWLock*)malloc(sizeof(RWLock));
  
    pRwLock->hRead = hRead;
    pRwLock->hWrite = hWrite;
    pRwLock->count = 0;
    pRwLock->state = STATE_EMPTY;
    return pRwLock;
}
     （3）获取读锁

[cpp] view plain copy print ?
  1. void read_lock(RWLock* pRwLock)  
  2. {  
  3.     assert(NULL != pRwLock);  
  4.       
  5.     WaitForSingleObject(pRwLock->hRead, INFINITE);  
  6.     pRwLock->counnt ++;  
  7.     if(1 == pRwLock->count){  
  8.         WaitForSingleObject(pRwLock->hWrite, INFINITE);  
  9.         pRwLock->state = STATE_READ;  
  10.     }  
  11.     ReleaseMutex(pRwLock->hRead);  
  12. }  
void read_lock(RWLock* pRwLock)
{
    assert(NULL != pRwLock);
    
    WaitForSingleObject(pRwLock->hRead, INFINITE);
    pRwLock->counnt ++;
    if(1 == pRwLock->count){
        WaitForSingleObject(pRwLock->hWrite, INFINITE);
        pRwLock->state = STATE_READ;
    }
    ReleaseMutex(pRwLock->hRead);
}
     （4）获取写锁
[cpp] view plain copy print ?
  1. void write_lock(RWLock* pRwLock)  
  2. {  
  3.     assert(NULL != pRwLock);  
  4.   
  5.     WaitForSingleObject(pRwLock->hWrite, INFINITE);  
  6.     pRwLock->state = STATE_WRITE;  
  7. }  
void write_lock(RWLock* pRwLock)
{
    assert(NULL != pRwLock);

    WaitForSingleObject(pRwLock->hWrite, INFINITE);
    pRwLock->state = STATE_WRITE;
}
     （5）释放读写锁
[cpp] view plain copy print ?
  1. void read_write_unlock(RWLock* pRwLock)  
  2. {  
  3.     assert(NULL != pRwLock);  
  4.   
  5.     if(STATE_READ == pRwLock->state){  
  6.         WaitForSingleObject(pRwLock->hRead, INFINITE);  
  7.         pRwLock->count --;  
  8.         if(0 == pRwLock->count){  
  9.             pRwLock->state = STATE_EMPTY;  
  10.             ReleaseMutex(pRwLock->hWrite);  
  11.         }  
  12.         ReleaseMutex(pRwLock->hRead);  
  13.     }else{  
  14.         pRwLock->state = STATE_EMPTY;  
  15.         ReleaseMutex(pRwLock->hWrite);  
  16.     }  
  17.       
  18.     return;  
  19. }  
void read_write_unlock(RWLock* pRwLock)
{
    assert(NULL != pRwLock);

    if(STATE_READ == pRwLock->state){
        WaitForSingleObject(pRwLock->hRead, INFINITE);
        pRwLock->count --;
        if(0 == pRwLock->count){
            pRwLock->state = STATE_EMPTY;
            ReleaseMutex(pRwLock->hWrite);
        }
        ReleaseMutex(pRwLock->hRead);
    }else{
        pRwLock->state = STATE_EMPTY;
        ReleaseMutex(pRwLock->hWrite);
    }
    
    return;
}

文章总结：
    （1）读写锁的优势只有在多读少写、代码段运行时间长这两个条件下才会效率达到最大化；
    （2）任何公共数据的修改都必须在锁里面完成；
    （3）读写锁有自己的应用场所，选择合适的应用环境十分重要；
    （4）编写读写锁很容易出错，朋友们应该多加练习；
    （5）读锁和写锁一定要分开使用，否则达不到效果。



（之嵌套锁） 


    嵌套锁这个概念，主要是为了根据编程中的一种情形引申出来的。什么情况呢，我们可以具体说明一下。假设你在处理一个公共函数的时候，因为中间涉及公共数据，所以你加了一个锁。但是，有一点比较悲哀。这个公共函数自身也加了一个锁，而且和你加的锁是一样的。所以，除非你的使用的是信号量，要不然你的程序一辈子也获取不了这个锁。

[cpp] view plain copy print ?
  1. HANDLE hLock;  
  2.   
  3. void sub_func()  
  4. {  
  5.     /*...*/  
  6.     WaitForSingleObject(hLock, INFINITE);  
  7.     do_something();  
  8.     ReleaseMutex(hLock);  
  9.     /*...*/  
  10. }  
  11.   
  12. void data_process()  
  13. {  
  14.     /*...*/      
  15.     WaitForSingleObject(hLock, INFINITE);  
  16.     sub_func();  
  17.     ReleaseMutex(hLock);  
  18.     /*...*/  
  19. }  
HANDLE hLock;

void sub_func()
{
    /*...*/
    WaitForSingleObject(hLock, INFINITE);
    do_something();
    ReleaseMutex(hLock);
    /*...*/
}

void data_process()
{
    /*...*/    
    WaitForSingleObject(hLock, INFINITE);
    sub_func();
    ReleaseMutex(hLock);
    /*...*/
}
    出现这种情况的原因很多。很重要的一个方面是因为软件的各个模块是不同的人负责的。所以本质上说，我们根本无法确定别人使用了什么样的锁。你也无权不让别人使用某个锁。所以，遇到这种情况，只好靠你自己了。嵌套锁就是不错的一个解决办法。


    （1）嵌套锁的数据结构

[cpp] view plain copy print ?
  1. typedef struct _NestLock  
  2. {  
  3.     int threadId;  
  4.     int count;  
  5.     HANDLE hLock;  
  6. }NestLock;  
  7.   
  8. NestLock* create_nest_lock(HANLDE hLock)  
  9. {  
  10.     NestLock* hNestLock = (NestLock*)malloc(sizeof(NestLock));  
  11.     assert(NULL != hNestLock);  
  12.   
  13.     hNestLock->threadId = hNestLock->count = 0;  
  14.     hNestLock->hLock = hLock;  
  15.     return hNestLock;  
  16. }  
typedef struct _NestLock
{
    int threadId;
    int count;
    HANDLE hLock;
}NestLock;

NestLock* create_nest_lock(HANLDE hLock)
{
    NestLock* hNestLock = (NestLock*)malloc(sizeof(NestLock));
    assert(NULL != hNestLock);

    hNestLock->threadId = hNestLock->count = 0;
    hNestLock->hLock = hLock;
    return hNestLock;
}

     （2）申请嵌套锁

[cpp] view plain copy print ?
  1. void get_nest_lock(NestLock* hNestLock)  
  2. {  
  3.     assert(NULL != hNestLock);  
  4.   
  5.     if(hNestLock->threadId == GetThreadId())  
  6.     {  
  7.         hNestLock->count ++;  
  8.     }else{  
  9.         WaitForSingleObject(hNestLock->hLock);  
  10.         hNestLock->count = 1;  
  11.         hNestLock->threadId = GetThreadId();  
  12.     }  
  13. }  
void get_nest_lock(NestLock* hNestLock)
{
    assert(NULL != hNestLock);

    if(hNestLock->threadId == GetThreadId())
    {
        hNestLock->count ++;
    }else{
        WaitForSingleObject(hNestLock->hLock);
        hNestLock->count = 1;
        hNestLock->threadId = GetThreadId();
    }
}

     （3）释放锁

[cpp] view plain copy print ?
  1. void release_nest_lock(NestLock* hNestLock)  
  2. {  
  3.     assert(NULL != hNestLock);  
  4.     assert(GetThreadId() == hNestLock->threadId);  
  5.   
  6.     hNestLock->count --;  
  7.     if(0 == hNestLock->count){  
  8.         hNestLock->threadId = 0;  
  9.         ReleaseMutex(hNestLock->hLock);  
  10.     }  
  11. }  
void release_nest_lock(NestLock* hNestLock)
{
    assert(NULL != hNestLock);
    assert(GetThreadId() == hNestLock->threadId);

    hNestLock->count --;
    if(0 == hNestLock->count){
        hNestLock->threadId = 0;
        ReleaseMutex(hNestLock->hLock);
    }
}

文章总结：
    （1）嵌套锁与其说是新的锁类型，不如说是统计锁而已
    （2）嵌套锁和普通的锁一样，使用十分方便
    （3）嵌套锁也有缺点，它给我们的锁检测带来了麻烦


（之生产者-消费者） 



    生产者-消费者是很有意思的一种算法。它的存在主要是两个目的，第一就是满足生产者对资源的不断创造；第二就是满足消费者对资源的不断索取。当然，因为空间是有限的，所以资源既不能无限存储，也不能无限索取。

    生产者的算法，

[cpp] view plain copy print ?
  1. WaitForSingleObject(hEmpty, INFINITE);  
  2. WaitForSingleObject(hMutex, INIFINITE);  
  3. /* produce new resources */  
  4. ReleaseMutex(hMutex);  
  5. ReleaseSemaphore(hFull, 1, NULL);  
    WaitForSingleObject(hEmpty, INFINITE);
    WaitForSingleObject(hMutex, INIFINITE);
    /* produce new resources */
    ReleaseMutex(hMutex);
    ReleaseSemaphore(hFull, 1, NULL);
    消费者的算法，

[cpp] view plain copy print ?
  1. WaitForSingleObject(hFull, INFINITE);  
  2. WaitForSingleObject(hMutex, INIFINITE);  
  3. /* consume old resources */  
  4. ReleaseMutex(hMutex);  
  5. ReleaseSemaphore(hEmpty, 1, NULL);  
    WaitForSingleObject(hFull, INFINITE);
    WaitForSingleObject(hMutex, INIFINITE);
    /* consume old resources */
    ReleaseMutex(hMutex);
    ReleaseSemaphore(hEmpty, 1, NULL);
    那么，有的朋友可能会说了，这么一个生产者-消费者算法有什么作用呢。我们可以看看它在多线程通信方面是怎么发挥作用的？首先我们定义一个数据结构，
[cpp] view plain copy print ?
  1. typedef struct _MESSAGE_QUEUE  
  2. {  
  3.     int threadId;  
  4.     int msgType[MAX_NUMBER];  
  5.     int count;  
  6.     HANDLE hFull;  
  7.     HANDLE hEmpty;  
  8.     HANDLE hMutex;  
  9. }MESSAGE_QUEUE;  
typedef struct _MESSAGE_QUEUE
{
    int threadId;
    int msgType[MAX_NUMBER];
    int count;
    HANDLE hFull;
    HANDLE hEmpty;
    HANDLE hMutex;
}MESSAGE_QUEUE;
    那么，此时如果我们需要对一个线程发送消息，该怎么发送呢，其实很简单。我们完全可以把它看成是一个生产者的操作。
[cpp] view plain copy print ?
  1. void send_mseesge(int threadId, MESSAGE_QUEUE* pQueue, int msg)  
  2. {  
  3.     assert(NULL != pQueue);  
  4.       
  5.     if(threadId != pQueue->threadId)  
  6.         return;  
  7.   
  8.     WaitForSingleObject(pQueue->hEmpty, INFINITE);  
  9.     WaitForSingleObject(pQueue->hMutex, INFINITE);  
  10.     pQueue->msgType[pQueue->count ++] = msg;  
  11.     ReleaseMutex(pQueue->hMutex);  
  12.     ReleaseSemaphore(pQueue->hFull, 1, NULL);      
  13. }  
void send_mseesge(int threadId, MESSAGE_QUEUE* pQueue, int msg)
{
    assert(NULL != pQueue);
    
    if(threadId != pQueue->threadId)
        return;

    WaitForSingleObject(pQueue->hEmpty, INFINITE);
    WaitForSingleObject(pQueue->hMutex, INFINITE);
    pQueue->msgType[pQueue->count ++] = msg;
    ReleaseMutex(pQueue->hMutex);
    ReleaseSemaphore(pQueue->hFull, 1, NULL);    
}
    既然前面说到发消息，那么线程自身就要对这些消息进行处理了。
[cpp] view plain copy print ?
  1. void get_message(MESSAGE_QUEUE* pQueue, int* msg)  
  2. {  
  3.     assert(NULL != pQueue && NULL != msg);  
  4.   
  5.     WaitForSingleObject(pQueue->hFull, INFINITE);  
  6.     WaitForSingleObject(pQueue->hMutex, INFINITE);  
  7.     *msg = pQueue->msgType[pQueue->count --];  
  8.     ReleaseMutex(pQueue->hMutex);  
  9.     ReleaseSemaphore(pQueue->hEmpty, 1, NULL);     
  10. }  
void get_message(MESSAGE_QUEUE* pQueue, int* msg)
{
    assert(NULL != pQueue && NULL != msg);

    WaitForSingleObject(pQueue->hFull, INFINITE);
    WaitForSingleObject(pQueue->hMutex, INFINITE);
    *msg = pQueue->msgType[pQueue->count --];
    ReleaseMutex(pQueue->hMutex);
    ReleaseSemaphore(pQueue->hEmpty, 1, NULL);   
}

 总结：
    （1）生产者-消费者只能使用semphore作为锁
    （2）编写代码的时候需要判断hFull和hEmpty的次序
    （3）掌握生产者-消费者的基本算法很重要，但更重要的是自己的实践




（之死锁） 

相信有过多线程编程经验的朋友，都吃过死锁的苦。除非你不使用多线程，否则死锁的可能性会一直存在。为什么会出现死锁呢？我想原因主要有下面几个方面：
    （1）个人使用锁的经验差异
    （2）模块使用锁的差异
    （3）版本之间的差异
    （4）分支之间的差异
    （5）修改代码和重构代码带来的差异

    不管什么原因，死锁的危机都是存在的。那么，通常出现的死锁都有哪些呢？我们可以一个一个看过来，

    （1）忘记释放锁

[cpp] view plain copy print ?
  1. void data_process()  
  2. {  
  3.     EnterCriticalSection();  
  4.   
  5.     if(/* error happens */)  
  6.         return;  
  7.   
  8.     LeaveCriticalSection();  
  9. }  
void data_process()
{
    EnterCriticalSection();

    if(/* error happens */)
        return;

    LeaveCriticalSection();
}
    （2）单线程重复申请锁

[cpp] view plain copy print ?
  1. void sub_func()  
  2. {  
  3.     EnterCriticalSection();  
  4.     do_something();  
  5.     LeaveCriticalSection();  
  6. }  
  7.   
  8. void data_process()  
  9. {  
  10.     EnterCriticalSection();  
  11.     sub_func();  
  12.     LeaveCriticalSection();  
  13. }  
void sub_func()
{
    EnterCriticalSection();
    do_something();
    LeaveCriticalSection();
}

void data_process()
{
    EnterCriticalSection();
    sub_func();
    LeaveCriticalSection();
}
     （3）双线程多锁申请
[cpp] view plain copy print ?
  1. void data_process1()  
  2. {  
  3.     EnterCriticalSection(&cs1);  
  4.     EnterCriticalSection(&cs2);  
  5.     do_something1();  
  6.     LeaveCriticalSection(&cs2);  
  7.     LeaveCriticalSection(&cs1);  
  8. }  
  9.   
  10. void data_process2()  
  11. {  
  12.     EnterCriticalSection(&cs2);  
  13.     EnterCriticalSection(&cs1);  
  14.     do_something2();  
  15.     LeaveCriticalSection(&cs1);  
  16.     LeaveCriticalSection(&cs2);  
  17. }  
void data_process1()
{
    EnterCriticalSection(&cs1);
    EnterCriticalSection(&cs2);
    do_something1();
    LeaveCriticalSection(&cs2);
    LeaveCriticalSection(&cs1);
}

void data_process2()
{
    EnterCriticalSection(&cs2);
    EnterCriticalSection(&cs1);
    do_something2();
    LeaveCriticalSection(&cs1);
    LeaveCriticalSection(&cs2);
}
     （4）环形锁申请
[cpp] view plain copy print ?
  1. /* 
  2. *             A   -  B 
  3. *             |      | 
  4. *             C   -  D 
  5. */  
/*
*             A   -  B
*             |      |
*             C   -  D
*/
    假设有A、B、C、D四个人在一起吃饭，每个人左右各有一只筷子。所以，这其中要是有一个人想吃饭，他必须首先拿起左边的筷子，再拿起右边的筷子。现在，我们让所有的人同时开始吃饭。那么就很有可能出现这种情况。每个人都拿起了左边的筷子，或者每个人都拿起了右边的筷子，为了吃饭，他们现在都在等另外一只筷子。此时每个人都想吃饭，同时每个人都不想放弃自己已经得到的一那只筷子。所以，事实上大家都吃不了饭。

总结：
    （1）死锁的危险始终存在，但是我们应该尽量减少这种危害存在的范围
    （2）解决死锁花费的代价是异常高昂的
    （3）最好的死锁处理方法就是在编写程序的时候尽可能检测到死锁
    （4）多线程是一把双刃剑，有了效率的提高当然就有死锁的危险
    （5）某些程序的死锁是可以容忍的，大不了重启机器，但是有些程序不行


（之避免死锁） 

预防死锁的注意事项：

（1）在编写多线程程序之前，首先编写正确的程序，然后再移植到多线程

（2）时刻检查自己写的程序有没有在跳出时忘记释放锁

（3）如果自己的模块可能重复使用一个锁，建议使用嵌套锁

（4）对于某些锁代码，不要临时重新编写，建议使用库里面的锁，或者自己曾经编写的锁

（5）如果某项业务需要获取多个锁，必须保证锁的按某种顺序获取，否则必定死锁

（6）编写简单的测试用例，验证有没有死锁

（7）编写验证死锁的程序，从源头避免死锁


    首先，定义基本的数据结构和宏，

[cpp] view plain copy print ?
  1. typedef struct _LOCK_INFO  
  2. {  
  3.     char lockName[32];  
  4.     HANDLE hLock;  
  5. }LOCK_INFO:  
  6.   
  7. typedef struct _THREAD_LOCK  
  8. {  
  9.     int threadId;  
  10.     LOCK_INFO* pLockInfo[32];  
  11. }THREAD_LOCK;  
  12.   
  13. #define CRITICAL_SECTION_TYPE 1   
  14. #define MUTEX_LOCK_TYPE       2   
  15. #define SEMAPHORE_LOCK_TYPE   3   
  16. #define NORMAL_LOCK_TYPE      4   
  17.   
  18. #define WaitForSingleObject(a, b) \   
  19.         WaitForSingleObject_stub((void*)a, NORMAL_LOCK_TYPE)  
  20.   
  21. #define EnterCriticalSection(a) \   
  22.         WaitForSingleObject_stub((void*)a, CRITICAL_SECTION_TYPE)  
  23.   
  24. #define ReleaseMutex(a) \   
  25.         ReleaseLock_stub((void*)a, MUTEX_LOCK_TYPE))  
  26.   
  27. #define ReleaseSemaphore(a, b, c) \   
  28.         ReleaseLock_stub((void*)a, SEMAPHORE_LOCK_TYPE))  
  29.   
  30. #define LeaveCriticalSection(a) \   
  31.         ReleaseLock_stub((void*)a, CRITICAL_SECTION_TYPE))  
typedef struct _LOCK_INFO
{
    char lockName[32];
    HANDLE hLock;
}LOCK_INFO:

typedef struct _THREAD_LOCK
{
    int threadId;
    LOCK_INFO* pLockInfo[32];
}THREAD_LOCK;

#define CRITICAL_SECTION_TYPE 1
#define MUTEX_LOCK_TYPE       2
#define SEMAPHORE_LOCK_TYPE   3
#define NORMAL_LOCK_TYPE      4

#define WaitForSingleObject(a, b) \
        WaitForSingleObject_stub((void*)a, NORMAL_LOCK_TYPE)

#define EnterCriticalSection(a) \
        WaitForSingleObject_stub((void*)a, CRITICAL_SECTION_TYPE)

#define ReleaseMutex(a) \
        ReleaseLock_stub((void*)a, MUTEX_LOCK_TYPE))

#define ReleaseSemaphore(a, b, c) \
        ReleaseLock_stub((void*)a, SEMAPHORE_LOCK_TYPE))

#define LeaveCriticalSection(a) \
        ReleaseLock_stub((void*)a, CRITICAL_SECTION_TYPE))
    然后，改写锁的申请函数，

[cpp] view plain copy print ?
  1. void WaitForSingleObject_stub(void* hLock, int type)  
  2. {  
  3.     /* step 1 */  
  4.     WaitForSingleObject(hDbgLock);  
  5.     /* check if lock loops arounds threads */  
  6.     ReleaseMutex(hDbgLock);  
  7.   
  8.     /* step 2 */  
  9.     if(NORMAL_LOCK_TYPE == type)  
  10.         WaitForSingleObject((HANDLE)hLock, INFINITE);  
  11.     else if(CRITICAL_SECTION_TYPE == type)  
  12.         EnterCriticalSection((LPCRITICAL_SECTION)hLock);  
  13.     else  
  14.         assert(0);  
  15.   
  16.     /* step 3 */  
  17.     WaitForSingleObject(hDbgLock);  
  18.     /* add lock to specified threadid list */  
  19.     ReleaseMutex(hDbgLock);  
  20. }  
void WaitForSingleObject_stub(void* hLock, int type)
{
    /* step 1 */
    WaitForSingleObject(hDbgLock);
    /* check if lock loops arounds threads */
    ReleaseMutex(hDbgLock);

    /* step 2 */
    if(NORMAL_LOCK_TYPE == type)
        WaitForSingleObject((HANDLE)hLock, INFINITE);
    else if(CRITICAL_SECTION_TYPE == type)
        EnterCriticalSection((LPCRITICAL_SECTION)hLock);
    else
        assert(0);

    /* step 3 */
    WaitForSingleObject(hDbgLock);
    /* add lock to specified threadid list */
    ReleaseMutex(hDbgLock);
}
    最后，需要改写锁的释放函数。

[cpp] view plain copy print ?
  1. void ReleaseLock_stub(void* hLock, int type)  
  2. {  
  3.     /* step 1 */  
  4.     WaitForSingleObject(hDbgLock);  
  5.     /* remove lock from specified threadid list */  
  6.     ReleaseMutex(hDbgLock);  
  7.   
  8.     /* step 2 */  
  9.     if(MUTEX_LOCK_TYPE))== type)  
  10.         ReleaseMutex(HANDLE)hLock);  
  11.     else if(SEMAPHORE_LOCK_TYPE == type)  
  12.         ReleaseSemaphore((HANDLE)hLock, 1, NULL);  
  13.     else if(CRITICAL_SECTION_TYPE == type)  
  14.         LeaveCriticalSection((LPCRITICAL_SECTION)hLock);  
  15.     assert(0);  
  16. }  
void ReleaseLock_stub(void* hLock, int type)
{
    /* step 1 */
    WaitForSingleObject(hDbgLock);
    /* remove lock from specified threadid list */
    ReleaseMutex(hDbgLock);

    /* step 2 */
    if(MUTEX_LOCK_TYPE))== type)
        ReleaseMutex(HANDLE)hLock);
    else if(SEMAPHORE_LOCK_TYPE == type)
        ReleaseSemaphore((HANDLE)hLock, 1, NULL);
    else if(CRITICAL_SECTION_TYPE == type)
        LeaveCriticalSection((LPCRITICAL_SECTION)hLock);
    assert(0);
}

（之多线程调试） 

  软件调试是我们软件开发过程中的重要一课。在前面，我们也讨论过程序调试，比如说这里。今天，我们还可以就软件调试多讲一些内容。比如说条件断点，数据断点，多线程断点等等。

[cpp] view plain copy print ?
  1. #include <stdio.h>   
  2. int value = 0;  
  3.   
  4. void test()  
  5. {  
  6.     int total;  
  7.     int index;  
  8.   
  9.     total = 0;  
  10.     for(index = 0; index < 100; index ++)  
  11.         total += index * index;  
  12.   
  13.     value = total;  
  14.     return ;  
  15. }  
  16.   
  17. int main()  
  18. {  
  19.     test();  
  20.     return 1;  
  21. }  
#include <stdio.h>
int value = 0;

void test()
{
	int total;
	int index;

	total = 0;
	for(index = 0; index < 100; index ++)
		total += index * index;

	value = total;
	return ;
}

int main()
{
	test();
	return 1;
}
（1）数据断点

    所谓数据断点，就是全局变量或者函数中的数计算的过程中，如果数据值本身发生了改变，就会触发断点。这里的数据有两种，一个是全局数据，一个函数内部的数据。


以全局数据value为例：

    a）按F10，运行程序，获取value的地址；

    b）Alt+F9，选择【DATA】->【Advanced】；

    c）在【Expression】中输入DW(0x0043178)，【ok】回车；

    d）F5继续运行程序，则程序会在value发生改变的时候停住。

以局部数据total为例，

    a）按F10，运行程序，获取value的地址；

    b）Alt+F9，选择【DATA】->【Advanced】；

    c）在【Expression】中输入total，在【Function】输入test，【ok】回车；

    d）F5继续运行程序，则程序同样会在total发生改变的时候停住。

（2）条件断点

    条件断点和数据断点差不多。只不过，数据断点在数据发生改变的时候就会断住，而条件断点只有在满足一定的条件下才会有断住。比如说，我们可以让test子程序在index==5的时候断住。


    a）按F10，运行程序，获取value的地址；

    b）Alt+F9，选择【DATA】->【Advanced】；

    c）在【Expression】中输入index==5，在【Function】输入test，【ok】回车；

    d）F5继续运行程序，则程序同样会在index==5的时候停住。

（3）多线程调试

    在VC上面对多程序的调试比较简单。如果想要对程序进行调试的话，首先F10，开始运行程序。其次，我们需要等线程创建之后才能设置断点，不然我们看到的程序只有main函数一个thread。

    a）单击【Debug】，选择【threads】，那么我们就可以开始多线程调试了；

    b）如果需要对某一个thread挂起，单击对应的thread，选择【suspend】即可；

    c）如果需要对某一个thread重新调度，单击对应的thread，选择【resume】即可；

    d）如果需要查看特定thread的堆栈，那么选择那个thread，然后【Set Focus】，关闭threads对话框，在堆栈窗口中即可看到；    

    e）如果某个线程被挂住，那么此时所有的线程都挂住了，如果你step运行，所有的threads都会参与运行；

    f）如果需要对某一个thread进行调试，那么需要对其他的thread进行suspend处理  。

总结：

    1）看内存、看堆栈、条件断点、数据断点需要综合使用，

    2）编程越早调试，越好，

    3）先编写好单线程程序，再编写好多线程程序，

    4）对于多线程来说，模块设计 > 编程预防 > 调试 > 事后补救。
   

（之无锁队列） 

     对于编写多线程的朋友来说，队列具有天生的互斥性。在队列里面，一个负责添加数据，一个负责处理数据。谁也不妨碍谁，谁也离不开谁。所以，队列具有天生的并行性。

[cpp] view plain copy print ?
  1. #define MAX_NUMBER 1000L   
  2. #define STATUS int   
  3. #define OK     0   
  4. #define FALSE -1   
  5.   
  6. typedef struct _QUEUE_DATA  
  7. {  
  8.     int data[MAX_NUMBER];  
  9.     int head;  
  10.     int tail;  
  11. }QUEUE_DATA;   
#define MAX_NUMBER 1000L
#define STATUS int
#define OK     0
#define FALSE -1

typedef struct _QUEUE_DATA
{
    int data[MAX_NUMBER];
    int head;
    int tail;
}QUEUE_DATA;
    此时，一个线程压入数据，操作为push_data，

[cpp] view plain copy print ?
  1. STATUS push_data(QUEUE_DATA* pQueue, int data)  
  2. {  
  3.     if(NULL == pQueue)  
  4.         return ERROR;  
  5.   
  6.     if(pQueue->head == ((pQueue->tail) + 1)% MAX_NUMBER)  
  7.         return ERROR;  
  8.   
  9.     pQueue->data[pQueue->tail] = data;  
  10.     pQueue->tail = (pQueue->tail + 1)% MAX_NUMBER;  
  11.     return OK;  
  12. }  
STATUS push_data(QUEUE_DATA* pQueue, int data)
{
    if(NULL == pQueue)
        return ERROR;

    if(pQueue->head == ((pQueue->tail) + 1)% MAX_NUMBER)
        return ERROR;

    pQueue->data[pQueue->tail] = data;
    pQueue->tail = (pQueue->tail + 1)% MAX_NUMBER;
    return OK;
}
    那么，还有一个线程就负责处理数据pop_data，

[cpp] view plain copy print ?
  1. STATUS pop_data(QUEUE_DATA* pQueue, int* pData)  
  2. {  
  3.     if(NULL == pQueue || NULL == pData)  
  4.         return ERROR;  
  5.   
  6.     if(pQueue->head == pQueue->tail)  
  7.         return ERROR;  
  8.   
  9.     *pData = pQueue->data[pQueue->head];  
  10.     pQueue->head = (pQueue->head + 1)% MAX_NUMBER;  
  11.     return OK;  
  12. }  
STATUS pop_data(QUEUE_DATA* pQueue, int* pData)
{
    if(NULL == pQueue || NULL == pData)
        return ERROR;

    if(pQueue->head == pQueue->tail)
        return ERROR;

    *pData = pQueue->data[pQueue->head];
    pQueue->head = (pQueue->head + 1)% MAX_NUMBER;
    return OK;
}


总结：
    （1）队列只适合两个线程并行使用，一个压入数据，一个弹出数据
    （2）队列是没有锁的并行，没有死锁的危险
    （3）队列中head和tail只有在计算结束之前的时候才能进行自增运算
  

（之顺序锁） 


    在互斥数据访问中有一种多读少写的情况。正对这么一种情形，我们也提出了读写锁的方案。但是呢，这个锁有些缺陷。什么缺陷呢？那就是，这个写锁需要在所有的读锁完成之后才能写。否则的话，写锁需要这么一直等下去。

    那么，有没有什么办法能使得写操作快速一点进行呢？那就是顺序锁。

[cpp] view plain copy print ?
  1. typedef struct _SEQUENCE_LOCK  
  2. {  
  3.     unsigned int sequence;  
  4.     HANDLE hLock;  
  5.   
  6. }SEQUENCE_LOCK;  
typedef struct _SEQUENCE_LOCK
{
    unsigned int sequence;
    HANDLE hLock;

}SEQUENCE_LOCK;
    有了这么一个数据结构之后。那么读锁怎么开始呢，

[cpp] view plain copy print ?
  1. unsigned int get_lock_begin(SEQUENCE_LOCK* hSeqLock)  
  2. {  
  3.     assert(NULL != hSeqLock);  
  4.   
  5.     return hSeqLock->sequence;      
  6. }     
  7.    
  8. int get_lock_retry(SEQUENCE_LOCK* hSeqLock, unsigned int value)  
  9. {  
  10.     unsigned int new_value;  
  11.     assert(NULL != hSeqLock);  
  12.   
  13.     new_value = hSeqLock->sequence;  
  14.     return (new_value & 0x1) || (new_value ^ value);      
  15. }  
unsigned int get_lock_begin(SEQUENCE_LOCK* hSeqLock)
{
    assert(NULL != hSeqLock);

    return hSeqLock->sequence;    
}   
 
int get_lock_retry(SEQUENCE_LOCK* hSeqLock, unsigned int value)
{
    unsigned int new_value;
    assert(NULL != hSeqLock);

    new_value = hSeqLock->sequence;
    return (new_value & 0x1) || (new_value ^ value);    
}
    自然写锁也需要修改了，

[cpp] view plain copy print ?
  1. void get_write_lock(SEQUENCE_LOCK* hSeqLock)  
  2. {  
  3.     assert(NULL != hSeqLock);  
  4.   
  5.     WaitForSingleObject(hSeqLock->hLock);  
  6.     hSeqLock->sequence ++;  
  7. }   
  8.   
  9. void release_write_lock(SEQUENCE_LOCK* hSeqLock)  
  10. {  
  11.     assert(NULL != hSeqLock);  
  12.   
  13.     hSeqLock->sequence ++;  
  14.     ReleaseMutex(hSeqLock->hLock);  
  15. }  
void get_write_lock(SEQUENCE_LOCK* hSeqLock)
{
    assert(NULL != hSeqLock);

    WaitForSingleObject(hSeqLock->hLock);
    hSeqLock->sequence ++;
} 

void release_write_lock(SEQUENCE_LOCK* hSeqLock)
{
    assert(NULL != hSeqLock);

    hSeqLock->sequence ++;
    ReleaseMutex(hSeqLock->hLock);
}
    如果应用呢，其实也不难，

[cpp] view plain copy print ?
  1. void read_process(SEQUENCE_LOCK* hSeqLock)  
  2. {  
  3.     unsigned int sequence;  
  4.   
  5.     do{  
  6.        sequence = get_lock_begin(hSeqLock);  
  7.        /* read operation  */  
  8.     }while(get_lock_retry(hSeqLock, sequence));  
  9. }  
  10.   
  11. void write_process(SEQUENCCE_LOCK* hSeqLock)  
  12. {  
  13.     get_write_lock(hSeqLock);  
  14.     /* write operation */  
  15.     release_write_lock(hSeqLock);  
  16. }  
void read_process(SEQUENCE_LOCK* hSeqLock)
{
    unsigned int sequence;

    do{
       sequence = get_lock_begin(hSeqLock);
       /* read operation  */
    }while(get_lock_retry(hSeqLock, sequence));
}

void write_process(SEQUENCCE_LOCK* hSeqLock)
{
    get_write_lock(hSeqLock);
    /* write operation */
    release_write_lock(hSeqLock);
}

总结：
    （1）读锁退出有两个条件，要么写操作正在进行呢，要么没有写锁

    （2）写锁之间需要互斥操作

    （3）互斥操作的数据不能是指针，否则有可能在访问的时候会造成异常，因为有可能边写边读

    （4）顺序锁代替不了读写锁，因为读写锁可以保证所有的数据操作，而顺序锁不行


（之无锁链表） 

    前面，为了使得写操作快速进行，我们定义了顺序锁。但是顺序锁有个缺点，那就是处理的数据不能是指针，否则可能会导致exception。那么有没有办法使得处理的数据包括指针呢？当然要是这个链表没有锁，那就更好了。

    针对这种无锁链表，我们可以初步分析一下，应该怎么设计呢？   

    （1）读操作没有锁，那么怎么判断读操作正在进行呢，只能靠标志位了；

    （2）写操作没有锁，那么读操作只能一个线程完成；

    （3）写操作中如果是添加，那么直接加在末尾即可；

    （4）写操作中如果是删除，那么应该先删除数据，然后等到当前没有操作访问删除数据时，释放内存，但是首节点不能删除。


    普通链表的结构为，

[cpp] view plain copy print ?
  1. typedef struct _LINK  
  2. {  
  3.     int data;  
  4.     struct _LINK* next;  
  5. }LINK;  
typedef struct _LINK
{
    int data;
    struct _LINK* next;
}LINK;
    假设此时有32个线程在访问链表，那么可以定义一个全局变量value，每一个bit表示一个thread，读操作怎么进行呢，

[cpp] view plain copy print ?
  1. void read_process()  
  2. {  
  3.     int index = get_index_from_threadid(GetThreadId());  
  4.     InterLockedOr(&value, 1 << index);  
  5.     /* read operation */  
  6.     InterLockedAnd(&value, ~(1<< index));      
  7. }  
void read_process()
{
    int index = get_index_from_threadid(GetThreadId());
    InterLockedOr(&value, 1 << index);
    /* read operation */
    InterLockedAnd(&value, ~(1<< index));    
}
    那么，写操作怎么进行呢，

[cpp] view plain copy print ?
  1. void write_process_add(LINK* pHead, LINK* pLink)  
  2. {  
  3.     /* add link to the tail of list */  
  4. }  
  5.   
  6. void write_process_del(LINK* pHead, LINK* pLink)  
  7. {  
  8.     delete_link_from_list(pHead, pLink);  
  9.     while(1){  
  10.         if(0 == value)  
  11.             break;  
  12.          Sleep(100);  
  13.     }  
  14.   
  15.     free(pLink);  
  16. }  
void write_process_add(LINK* pHead, LINK* pLink)
{
    /* add link to the tail of list */
}

void write_process_del(LINK* pHead, LINK* pLink)
{
    delete_link_from_list(pHead, pLink);
    while(1){
        if(0 == value)
            break;
         Sleep(100);
    }

    free(pLink);
}
    其中链表的删除操作为，

[cpp] view plain copy print ?
  1. /* 
  2. *  From:   
  3. *    ->   a  ->  b -> c -> d 
  4. * 
  5. *  To: 
  6. *        ----------------- 
  7. *        |               V 
  8. *    ->  a        b  ->  c ->d  
  9. *                                
  10. */  
/*
*  From:  
*    ->   a  ->  b -> c -> d
*
*  To:
*        -----------------
*        |               V
*    ->  a        b  ->  c ->d 
*                               
*/


总结：

    （1）这种无锁链表有很多局限：多读少写、注意使用原子操作、不能删除头结点、数据只能添加到尾部、注意删除顺序和方法、读线程个数有限制等等；

    （2）写操作在操作前需要等待所有的读操作，否则有可能发生异常；

    （3）写操作不能被多个线程使用；

    （4）无锁链表应用范围有限，只是特殊情况下的一种方案而已。



（之多线程数据结构） 

     要想编写多线程，那就要使用锁。而在软件编写中，数据结构是少不了的。所以，我们在编写多线程的时候，就需要考虑一下如何在数据结构中插入锁。当然，有些数据结构是没有锁的，所以自然这个锁并不一定是必须的。

    比如说，我们编写一个多线程堆栈，应该怎么做呢，

[cpp] view plain copy print ?
  1. typedef struct _STACK  
  2. {  
  3.     void* pData;  
  4.     int maxLen;  
  5.     int top;  
  6.     void* hLock;  
  7.       
  8.     STATUS (*push)(struct _STACK* pStack, void* pData, int size);  
  9.     STATUS (*pop)(struct _STACK* pStack, void* pData, int size);     
  10. }STACK;  
typedef struct _STACK
{
    void* pData;
    int maxLen;
    int top;
    void* hLock;
    
    STATUS (*push)(struct _STACK* pStack, void* pData, int size);
    STATUS (*pop)(struct _STACK* pStack, void* pData, int size);   
}STACK;
    (1) 初始化操作

[cpp] view plain copy print ?
  1. STACK* get_new_stack(void* pData, int len, void* pLock)  
  2. {  
  3.     STACK* pStack;  
  4.         
  5.     if(NULL == pData || 0 == len)  
  6.         return NULL;  
  7.   
  8.     pStack = (STACK*)malloc(sizeof(STACK));  
  9.     assert(NULL != pStack);  
  10.   
  11.     memset(pStack, 0, sizeof(STACK));  
  12.     pStack->pData  = pData;  
  13.     pStack->maxLen = len;  
  14.       
  15.     if(NULL != pLock)  
  16.         pStack->hLock = pLock;  
  17.   
  18.     return pStack;  
  19. }    
STACK* get_new_stack(void* pData, int len, void* pLock)
{
    STACK* pStack;
      
    if(NULL == pData || 0 == len)
        return NULL;

    pStack = (STACK*)malloc(sizeof(STACK));
    assert(NULL != pStack);

    memset(pStack, 0, sizeof(STACK));
    pStack->pData  = pData;
    pStack->maxLen = len;
    
    if(NULL != pLock)
        pStack->hLock = pLock;

    return pStack;
}
    (2) 添加数据
[cpp] view plain copy print ?
  1. STATUS push(struct _STACK* pStack, void* pData, int size)  
  2. {  
  3.     assert(NULL != pStack && NULL != pData);  
  4.   
  5.     if(NULL != pStack->hLock)  
  6.         WaitForSingleObject((HANDLE)pStack->hLock, INFINITE);  
  7.   
  8.     if(pStack->top == pStack->maxLen){  
  9.         if(NULL != pStack->hLock)  
  10.             ReleaseMutex((HANDLE)pStack->hLock);  
  11.           
  12.         return ERROR;  
  13.     }  
  14.   
  15.     memmove((char*)pStack->pData + size * pStack->top, (char*)pData, size);  
  16.     pStack->top ++;  
  17.       
  18.     if(NULL != pStack->hLock)  
  19.         ReleaseMutex((HANDLE)pStack->hLock);          
  20.   
  21.     return OK;  
  22. }  
STATUS push(struct _STACK* pStack, void* pData, int size)
{
    assert(NULL != pStack && NULL != pData);

    if(NULL != pStack->hLock)
        WaitForSingleObject((HANDLE)pStack->hLock, INFINITE);

    if(pStack->top == pStack->maxLen){
        if(NULL != pStack->hLock)
            ReleaseMutex((HANDLE)pStack->hLock);
        
        return ERROR;
    }

    memmove((char*)pStack->pData + size * pStack->top, (char*)pData, size);
    pStack->top ++;
    
    if(NULL != pStack->hLock)
        ReleaseMutex((HANDLE)pStack->hLock);        

    return OK;
}
    (3) 对2进行优化，因为判断的条件比较复杂

[cpp] view plain copy print ?
  1. #define STACK_CHECK_LOCK(hLock) \   
  2. do{\  
  3.     if(hLock)\  
  4.         WaitForSingleObject((HANDLE)hLock, INFINITE);\  
  5. }while(0)  
  6.   
  7. #define STACK_CHECK_UNLOCK(hLock) \   
  8. do{\  
  9.     if(hLock)\  
  10.         ReleaseMutex((HANDLE)hLock);\  
  11. }while(0)  
#define STACK_CHECK_LOCK(hLock) \
do{\
    if(hLock)\
        WaitForSingleObject((HANDLE)hLock, INFINITE);\
}while(0)

#define STACK_CHECK_UNLOCK(hLock) \
do{\
    if(hLock)\
        ReleaseMutex((HANDLE)hLock);\
}while(0)
    所以，2的代码可以修改为，

[cpp] view plain copy print ?
  1. STATUS push(struct _STACK* pStack, void* pData, int size)  
  2. {  
  3.     assert(NULL != pStack && NULL != pData);  
  4.   
  5.     STACK_CHECK_LOCK(pStack->hLock);  
  6.   
  7.     if(pStack->top == pStack->maxLen){  
  8.         STACK_CHECK_UNLOCK(pStack->hLock);  
  9.         return ERROR;  
  10.     }  
  11.   
  12.     memmove((char*)pStack->pData + size * pStack->top, (char*)pData, size);  
  13.     pStack->top ++;  
  14.       
  15.     STACK_CHECK_UNLOCK(pStack->hLock);        
  16.     return OK;  
  17. }  
STATUS push(struct _STACK* pStack, void* pData, int size)
{
    assert(NULL != pStack && NULL != pData);

    STACK_CHECK_LOCK(pStack->hLock);

    if(pStack->top == pStack->maxLen){
        STACK_CHECK_UNLOCK(pStack->hLock);
        return ERROR;
    }

    memmove((char*)pStack->pData + size * pStack->top, (char*)pData, size);
    pStack->top ++;
    
    STACK_CHECK_UNLOCK(pStack->hLock);      
    return OK;
}

总结:
    (1)  一般来说，比较好的数据结构要兼有多线程和没有多线程两种情况
    (2)  如果需要用其他的锁代替mutex，直接换掉就可以，十分方便

（之多核编程） 

   多核编程并不是最近才兴起的新鲜事物。早在intel发布双核cpu之前，多核编程已经在业内存在了，只不过那时候是多处理器编程而已。为了实现多核编程，人们开发实现了几种多核编程的标准。open-mp就是其中的一种。对于open-mp还不太熟悉的朋友，可以参照维基百科的相关解释。


    open-mp的格式非常简单，原理也不难。它的基本原理就是创建多个线程，操作系统把这几个线程分到几个核上面同时执行，从而可以达到快速执行代码的目的。比如说，我们可以编写一个简单的例子。


    在编写open-mp程序之前，朋友们应该注意下面三点，

    (1) 使用vs2005或者以上的版本编写open-mp程序；

    (2) 编写程序的时候，选择【Property Pages】->【Configuration Properties】->【c/c++】->【language】->【OpenMp Support】，打开开关；       

    (3) 添加#include <omp.h> 声明。


    首先，我们编写简单的一个打印程序，看看结果。

[cpp] view plain copy print ?
  1. #include <omp.h>   
  2.   
  3. void print()  
  4. {  
  5.     int i;  
  6. #pragma omp parallel for   
  7.     for(i = 0; i < 100; i ++)  
  8.     {  
  9.         printf("%d\n", i);  
  10.     }      
  11. }  
#include <omp.h>

void print()
{
    int i;
#pragma omp parallel for
    for(i = 0; i < 100; i ++)
    {
        printf("%d\n", i);
    }    
}
    上面这段代码好像也没有什么特别的地方，但是我们可以在printf设一个断点，看看函数调用堆栈，

[cpp] view plain copy print ?
  1. openmp.exe!print$omp$1()  Line 14   C++  
  2. vcompd.dll!_vcomp::ParallelRegion::HandlerThreadFunc()  + 0x19c bytes     
  3. vcompd.dll!_vcomp::ParallelRegion::HandlerThreadFunc()  + 0xe0 bytes      
  4. vcompd.dll!_InvokeThreadTeam@12()  + 0x98 bytes   
  5. vcompd.dll!__vcomp_fork()  + 0x1cd bytes      
  6. openmp.exe!print()  Line 11 + 0xe bytes C++  
  7. openmp.exe!wmain(int argc=1, wchar_t * * argv=0x003b5ba8)  Line 22  C++  
  8. openmp.exe!__tmainCRTStartup()  Line 583 + 0x19 bytes   C  
  9. openmp.exe!wmainCRTStartup()  Line 403  C  
  10. kernel32.dll!7c817077()       
  11. [Frames below may be incorrect and/or missing, no symbols loaded for kernel32.dll]  
openmp.exe!print$omp$1()  Line 14	C++
vcompd.dll!_vcomp::ParallelRegion::HandlerThreadFunc()  + 0x19c bytes	
vcompd.dll!_vcomp::ParallelRegion::HandlerThreadFunc()  + 0xe0 bytes	
vcompd.dll!_InvokeThreadTeam@12()  + 0x98 bytes	
vcompd.dll!__vcomp_fork()  + 0x1cd bytes	
openmp.exe!print()  Line 11 + 0xe bytes	C++
openmp.exe!wmain(int argc=1, wchar_t * * argv=0x003b5ba8)  Line 22	C++
openmp.exe!__tmainCRTStartup()  Line 583 + 0x19 bytes	C
openmp.exe!wmainCRTStartup()  Line 403	C
kernel32.dll!7c817077() 	
[Frames below may be incorrect and/or missing, no symbols loaded for kernel32.dll]
    我们看可以看到函数堆栈和平时看到的一般函数调用确实不一样，但这确实也说明不了什么，不过没有关系，我们可以做一个简单的测试，

[cpp] view plain copy print ?
  1. #include "stdafx.h"   
  2. #include <windows.h>   
  3. #include <omp.h>   
  4.   
  5. #define NUMBER 1000000000   
  6.   
  7. int process(int start, int end)  
  8. {  
  9.     int total;  
  10.   
  11.     total = 0;  
  12.     while(start < end){  
  13.         total += start %2;  
  14.         start ++;  
  15.     }  
  16.   
  17.     return total;  
  18. }  
  19.   
  20. void test1()  
  21. {  
  22.     int i;  
  23.     int time;  
  24.     struct {  
  25.         int start;  
  26.         int end;  
  27.     }value[] = {  
  28.         {0 , NUMBER >> 1},  
  29.         {NUMBER >> 1, NUMBER}  
  30.     };  
  31.     int total[2] = {0};  
  32.     int result;  
  33.   
  34.     time = GetTickCount();  
  35.   
  36. #pragma omp parallel for   
  37.     for(i = 0; i < 2; i ++)  
  38.     {  
  39.         total[i] = process(value[i].start, value[i].end);  
  40.     }      
  41.       
  42.     result = total[0] + total[1];  
  43.     printf("%d\n", GetTickCount() - time);  
  44. }  
  45.   
  46. void test2()  
  47. {  
  48.     int i;  
  49.     int value;  
  50.     int total;  
  51.   
  52.     total = 0;  
  53.     value = GetTickCount();  
  54.   
  55.     for(i = 0; i < NUMBER; i++)  
  56.     {  
  57.         total += i %2;  
  58.     }  
  59.     printf("%d\n", GetTickCount()-value);  
  60. }  
  61.   
  62.   
  63. int _tmain(int argc, _TCHAR* argv[])  
  64. {  
  65.     test1();  
  66.     test2();  
  67.     return 0;  
  68. }  
#include "stdafx.h"
#include <windows.h>
#include <omp.h>

#define NUMBER 1000000000

int process(int start, int end)
{
	int total;

	total = 0;
	while(start < end){
		total += start %2;
		start ++;
	}

	return total;
}

void test1()
{
	int i;
	int time;
	struct {
		int start;
		int end;
	}value[] = {
		{0 , NUMBER >> 1},
		{NUMBER >> 1, NUMBER}
	};
	int total[2] = {0};
	int result;

	time = GetTickCount();

#pragma omp parallel for
	for(i = 0; i < 2; i ++)
	{
		total[i] = process(value[i].start, value[i].end);
	}    
	
	result = total[0] + total[1];
	printf("%d\n", GetTickCount() - time);
}

void test2()
{
	int i;
	int value;
	int total;

	total = 0;
	value = GetTickCount();

	for(i = 0; i < NUMBER; i++)
	{
		total += i %2;
	}
	printf("%d\n", GetTickCount()-value);
}


int _tmain(int argc, _TCHAR* argv[])
{
	test1();
	test2();
	return 0;
}

    test1和test2完成的功能都是一样的，但是明显test1要比test2花费的时间要少很多，这明显就是多核编程的好处。所以要想实现多核编程最大程度上的并行运算，就必须把运
算拆分成n个子运算，并且尽量减少使用锁。


总结：
    (1) 这篇文章只是介绍性的博客，详细内容可以参考周伟明先生的博客；

    (2) 关于多核编程更具体的细节和方法，可以参考《多核计算与程序设计》这本书；

    (3) 编写多核编程需要的条件很简单，cpu支持多核、打开openmp开关、添加omp头文件，剩下的就是多多练习了；

    (4) 并行运算的时候少使用锁，否则效率会大打折扣。


（之优先级反转） 

    优先级反转对于编写应用层的人员来说不大会发生，但是对于操作系统的设计者来说确是一个逃不过去的问题。要知道怎么样处理优先级反转？那么先看看它是怎么发生的。

    （1）调度队列和线程优先级

    在操作系统中，线程的状态有很多种。比如说，线程的状态可能是suspend、block、ready、die几种类型。我们把所有的ready线程放在一个队列里面，这就构成了一个基本的调度队列。

    我们还知道，为了对所有的线程进行有差别的时间调度，我们对所有的线程分配了优先级。打个比方，调度队列有32个线程，每个线程的优先级也是1到32。这些优先级对于线程来说有什么意义呢？那就是，高优先级可以获得较多的时间片运行机会。进一步极端一点说，优先级为32可以32个基本时间片，那么优先级为1的线程只能获得一个时间片的运行机会。

    （2）锁和线程

    在队列调度过程当中，高优先级的线程获得较多的运行机会，而与此对应的低优先级线程运行的机会较少。举个例子来说，现在有32个线程，线程的优先级分布在1~32之间。那么这些程序怎么运行呢，


    线程0x20  优先级32   时间片 32个

    线程0x1F  优先级31   时间片 31个

    线程0x1E  优先级30   时间片 30个

    /* 其他线程 */

    线程0x01  优先级01   时间片 01个

    

    所以如果总的时间片为(1 + 32) * (32 / 2) = 528, 所以一段时间内每个线程都有运行的机会。只不过，各个线程运行的机会不一样而已。但是这一切都因为锁的存在发生了改变。假设现在线程0x20和0x1都在争取一个锁，而这个锁此时正处在线程0x01的运行时间片内，所以线程0x01获得了锁。那么线程0x20此时只好退出运行队列，静静等待线程0x1退出锁了。

    糟糕的还不止这一点，前面我们说过低优先级的线程运行机会较少。所以，线程0x01获得运行的机会只是1/528，即使线程0x20退出了队列，那只有1/496，其中 496 = (1 + 31) / 2 * 31。如果线程0x01运行的时间还比较长，那就比较悲催了。线程0x20还要等待多长时间才能获得线程0x01的锁，那就只有天知道了。此时，原来的优先级也失去了意义，这才是优先级发生反转的真实原因。


    （3）解决方法
    原来制定优先级的目的就是为了让有的程序运行时间长一点，有的程序运行时间短一点。然而，这一切在锁面前从优点变成了缺点。那么解决的办法是什么呢？其实也不难，那就是提高线程0x01的优先级，尽快让线程0x01尽快退出锁。线程0x01和线程0x20交换一下优先级的方法就不错。


总结：

    （1）优先级反转提醒我们使用锁的代码段应尽量短；

    （2）注意用小锁代替大锁，减少冲突的机会；

    （3）如果锁保护的代码段很短，直接使用原子锁忙等也是不错的一个方法。

（之大结局） 

  多线程一直是我比较喜欢的话题，当然也是很多朋友比较害怕的话题。喜欢它，因为它确实可以提高pc的使用效率；讨厌它，因为如果对它处理不好，反而会导致更大的麻烦。这里断断续续写了这么多，没有什么新意，主要是想结合自己这么多年的个人经历谈一谈自己的想法而已。真心希望这些文章能够达到抛砖引玉的效果，更多的达人可以奉献出自己的经验和方法。谢谢。


    （01）多线程的哪些儿事（优先级反转）

    （02）多线程的哪些儿事（多核编程）

    （03）多线程的哪些儿事（多线程数据结构）

    （04）多线程的哪些儿事（无锁链表）

    （05）多线程的哪些儿事（顺序锁）

    （06）多线程的哪些儿事（无锁队列）

    （07）多线程的哪些儿事（多线程调试）

    （08）多线程的哪些儿事（避免死锁）

    （09）多线程的哪些儿事（生产者-消费者）

    （10）多线程的哪些儿事（嵌套锁）

    （11）多线程的哪些儿事（读写锁）

    （12）多线程的哪些儿事（原子锁）

    （13）多线程的哪些儿事（C++锁）

    （14）多线程的哪些儿事（windows锁）

    （15）多线程的哪些儿事（自旋锁）

    （16）多线程的哪些儿事（数据互斥）

    （17）多线程的哪些儿事（数据同步）

    （18）多线程的哪些儿事（死锁）

    （19）多线程的哪些儿事（基础篇）



pizi0475
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
多线程的那点儿事-线程编码
07-21
多线程的那点儿事
几种python多进程通信技术实例演示
weixin_39888010的博客
02-10 814
Python中的多进程通信通常使用以下几种方法，选择通信方式取决于多进程间通信的需求和限制，可以根据不同的场景选择不同的通信机制：
【转】多进程那点事儿
wolinxuebin的专栏
10-23 3047
作者：费晓行 个人空间：http://my.csdn.net/feixiaoxing 1.多线程的那点儿事（基础篇） 【 声明：版权所有，欢迎转载，请勿用于商业用途。  联系信箱：feixiaoxing @163.com】          多线程编程是现代软件技术中很重要的一个环节。要弄懂多线程，这就要牵涉到多进程？当然，要了解到多进程，就要涉及到操作系统。不
C++多线程-数据互斥
逍遥云恋
01-09 535
在多线程存在的环境中，除了堆栈中的临时数据之外，所有的数据都是共享的。如果我们需要线程之间正确地运行，那么务必需要保证公共数据的执行和计算是正确的。简单一点说，就是保证数据在执行的时候必须是互斥的。否则，如果两个或者多个线程在同一时刻对数据进行了操作，那么后果是不可想象的。 也许有的朋友会说，不光数据需要保护，代码也需要保护。提出这个观点的朋友只看到了数据访问互斥的表象。在程序的运行空间里面，什么...
GetTickCount()获时钟问题
qq_39993240的博客
04-25 503
多核多线程使用时，冗余量比较大
在linux中进程表示的是,Linux进程的表示
weixin_33524408的博客
04-28 313
2、linux进程相关的数据结构首先来看内核描述进程所用的数据结构。在Linux内核0.11版本中，进程数据结构的定义在sched.h文件中，定义如下structtask_struct {/* these are hardcoded - don't touch */longstate;/*表示进程当前的状态的字段。关于进程状态字段相关值的定义也在shced.h文件中*/longcounter; ...
C++中多线程与Singleton的那些事儿
01-20
前言 　前段时间在网上看到了个的面试题，大概...本文主要将从基本的单线程中的Singleton开始，慢慢讲述多线程与Singleton的那些事。 　单线程 　在单线程下，下面这个是常见的写法： template class Singleton
多线程的那点儿事（基础篇）
12-22
多线程编程是现代软件技术中很重要的一个环节。要弄懂多线程，这要牵涉到多进程？当然，要了解到多进程，要涉及到操作系统。不过大家也不要紧张，听我慢慢道来。这其中的环节其实并不复杂。  （1）单CPU下的多线程...
说说C#多线程那些事-线程基础
12-22
现在我以一个初学者的心态，把我所理解的“多线程”描述给大家。这一次是系列文章，比较完整的展示与线程相关的基本概念。希望对初学者有所帮助。 　如果你是高手，请你别继续看，会浪费你宝贵的时间。 　一、基本...
c++11,基于原子操作的速度极快的多线程无锁队列
m0_58186648的博客
01-03 2724
c++11,基于原子操作的速度极快的多线程无锁队列
windows时间函数大全
sunnysheng的专栏
07-31 568
windows时间函数大全 - 浪迹天涯 - C++博客[ http://www.cppblog.com/qiujian5628/archive/2008/01/29/42113.html ] ... windows时间函数大全 我们在衡量一个函数运行时间，或者判断一个算法的时间效率，或者在程序中我们需要一个定时器，定时执行一个特定的操作，比如
GetTickCount()函数的陷阱！
weixin_34029680的博客
05-06 1708
开发中经经常使用GetTickCount()函数来进行间隔时间的推断。如推断某一段代码运行花了多少时间等，使用比較方便。 可是仅仅针对寻常的一些測试。近期开发一个服务程序时，也在代码中用GetTickCount()来进行推断，大体格式例如以下: DWORD dwBegin = 0; void Thread_Run(void) { while(TRUE) { DWORD dwN...
windows多线程同步机制---原子锁
Barry的博客
02-16 2549
原子锁     执行单个指令时,锁定操作,不允许其他线程访问.（循环执行原子锁运算时，循环过程中也是不允许其他线程访问，直到循环执行完原子操作）        原理介绍： 线程执行加减法时，依靠寄存器来计算，切换线程之前，先保存寄存器的值到线程中，再次轮到该线程执行时，把值恢复到寄存器中继续来计算。   问题描述： 想通过多线程执行g_nValue++的操作（即累加一个值）
task_struct到底是个神马东西？
福大馨的博客
06-07 777
上回我们说到了常用的操作系统进程调度算法，学过操作系统的同学应该都知道操作系统的四大职能：进程管理、内存管理、设备管理以及文件系统的管理。 那么最重要的职能之一：进程管理，是如何进行的呢？首先在要管理一个进程的时候，我们需要知道某个进程的具体信息，比如进程的PID、优先级等等，所以我们就需要一个结构体来保存这些信息，在Linux中这个结构体就是task_struct，也就是我们平常所说的PCB（
linux任务数据结构实验,Linux核心数据结构--进程或任务
weixin_32498321的博客
05-12 69
struct task_struct{/* these are hardcoded - don't touch */volatile long state; /* -1 unrunnable, 0 runnable, >0 stopped */long counter;long priority;u...
c++ 多线程 release 崩溃怎么回事
最新发布
07-13
关于你提到的C++多线程Release崩溃的问题，有几种可能的原因： 1. 数据竞争：多个线程同时访问或修改共享数据，没有进行适当的同步操作（例如使用互斥锁或原子操作），可能导致未定义行为和崩溃。 2. 内存管理问题...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值