在Linux中使用线程

迷南。 2022-08-04 11:59 176阅读 0赞

我并不假定你会使用Linux的线程，所以在这里就简单的介绍一下。如果你之前有过多线程方面的编程经验，完全可以忽略本文的内容，因为它非常的初级。

首先说明一下，在Linux编写多线程程序需要包含头文件pthread.h。也就是说你在任何采用多线程设计的程序中都会看到类似这样的代码：

**\[cpp\]**  [view plain][] [copy][view plain]

1.  ＃include <pthread.h>

当然，进包含一个头文件是不能搞定线程的，还需要连接libpthread.so这个库，因此在程序连接阶段应该有类似这样的指令：

gcc program.o -o program -lpthread

# 1. 第一个例子 #

在Linux下创建的线程的API接口是pthread\_create()，它的完整定义是：

**\[cpp\]**  [view plain][] [copy][view plain]

1.  **int** pthread\_create(pthread\_t \***thread**, **const** pthread\_attr\_t \*attr, **void** \*(\*start\_routine)(**void**\*) **void** \*arg);

当你的程序调用了这个接口之后，就会产生一个线程，而这个线程的入口函数就是start\_routine()。如果线程创建成功，这个接口会返回0。

start\_routine()函数有一个参数，这个参数就是pthread\_create的最后一个参数arg。这种设计可以在线程创建之前就帮它准备好一些专有数据，最典型的用法就是使用C++编程时的this指针。start\_routine()有一个返回值，这个返回值可以通过pthread\_join()接口获得。

pthread\_create()接口的第一个参数是一个返回参数。当一个新的线程调用成功之后，就会通过这个参数将线程的句柄返回给调用者，以便对这个线程进行管理。

pthread\_create()接口的第二个参数用于设置线程的属性。这个参数是可选的，当不需要修改线程的默认属性时，给它传递NULL就行。具体线程有那些属性，我们后面再做介绍。

好，那么我们就利用这些接口，来完成在Linux上的第一个多线程程序，见代码1所示：

**\[cpp\]**  [view plain][] [copy][view plain]

1.  \#include <stdio.h>  
2.  \#include <pthread.h>  
3.  **void**\* **thread**( **void** \*arg )  
4.  \{  
5.      printf( "This is a thread and arg = %d.\\n", \*(**int**\*)arg);  
6.      \*(**int**\*)arg = 0;  
7.      **return** arg;  
8.  \}  
9.  **int** main( **int** argc, **char** \*argv\[\] )  
10. \{  
11.     pthread\_t th;  
12.     **int** ret;  
13.     **int** arg = 10;  
14.     **int** \*thread\_ret = NULL;  
15.     ret = pthread\_create( &th, NULL, **thread**, &arg );  
16.     **if**( ret != 0 )\{  
17.         printf( "Create thread error!\\n");  
18.         **return** -1;  
19.     \}  
20.     printf( "This is the main process.\\n" );  
21.     pthread\_join( th, (**void**\*\*)&thread\_ret );  
22.     printf( "thread\_ret = %d.\\n", \*thread\_ret );  
23.     **return** 0;  
24. \}

代码1第一个多线程编程例子

将这段代码保存为thread.c文件，可以执行下面的命令来生成可执行文件：

$ gcc thread.c -o thread -lpthread

这段代码的执行结果可能是这样：

$ ./thread

This is the main process.

This is a thread and arg = 10.

thread\_ret = 0.

注意，我说的是可能有这样的结果，在不同的环境下可能会有出入。因为这是多线程程序，线程代码可能先于第20行代码被执行。

我们回过头来再分析一下这段代码。在第15行调用pthread\_create()接口创建了一个新的线程，这个线程的入口函数是start\_thread()，并且给这个入口函数传递了一个参数，且参数值为10。这个新创建的线程要执行的任务非常简单，只是将显示“This is a thread and arg = 10”这个字符串，因为arg这个参数值已经定义好了，就是10。之后线程将arg参数的值修改为0，并将它作为线程的返回值返回给系统。与此同时，主进程做的事情就是继续判断这个线程是否创建成功了。在我们的例子中基本上没有创建失败的可能。主进程会继续输出“This is the main process”字符串，然后调用pthread\_join()接口与刚才的创建进行合并。这个接口的第一个参数就是新创建线程的句柄了，而第二个参数就会去接受线程的返回值。pthread\_join()接口会阻塞主进程的执行，直到合并的线程执行结束。由于线程在结束之后会将0返回给系统，那么pthread\_join()获得的线程返回值自然也就是0。输出结果“thread\_ret = 0”也证实了这一点。

那么现在有一个问题，那就是pthread\_join()接口干了什么？什么是线程合并呢？

# 2. 线程的合并与分离 #

我们首先要明确的一个问题就是什么是线程的合并。从前面的叙述中读者们已经了解到了，pthread\_create()接口负责创建了一个线程。那么线程也属于系统的资源，这跟内存没什么两样，而且线程本身也要占据一定的内存空间。众所周知的一个问题就是C或C++编程中如果要通过malloc()或new分配了一块内存，就必须使用free()或delete来回收这块内存，否则就会产生著名的内存泄漏问题。既然线程和内存没什么两样，那么有创建就必须得有回收，否则就会产生另外一个著名的资源泄漏问题，这同样也是一个严重的问题。那么线程的合并就是回收线程资源了。

线程的合并是一种主动回收线程资源的方案。当一个进程或线程调用了针对其它线程的pthread\_join()接口，就是线程合并了。这个接口会阻塞调用进程或线程，直到被合并的线程结束为止。当被合并线程结束，pthread\_join()接口就会回收这个线程的资源，并将这个线程的返回值返回给合并者。

与线程合并相对应的另外一种线程资源回收机制是线程分离，调用接口是pthread\_detach()。线程分离是将线程资源的回收工作交由系统自动来完成，也就是说当被分离的线程结束之后，系统会自动回收它的资源。因为线程分离是启动系统的自动回收机制，那么程序也就无法获得被分离线程的返回值，这就使得pthread\_detach()接口只要拥有一个参数就行了，那就是被分离线程句柄。

线程合并和线程分离都是用于回收线程资源的，可以根据不同的业务场景酌情使用。不管有什么理由，你都必须选择其中一种，否则就会引发资源泄漏的问题，这个问题与内存泄漏同样可怕。

# 3. 线程的属性 #

前面还说到过线程是有属性的，这个属性由一个线程属性对象来描述。线程属性对象由pthread\_attr\_init()接口初始化，并由pthread\_attr\_destory()来销毁，它们的完整定义是：

**\[cpp\]**  [view plain][] [copy][view plain]

1.  **int** pthread\_attr\_init(pthread\_attr\_t \*attr);  
2.  **int** pthread\_attr\_destory(pthread\_attr\_t \*attr);

那么线程拥有哪些属性呢？一般地，Linux下的线程有：绑定属性、分离属性、调度属性、堆栈大小属性和满占警戒区大小属性。下面我们就分别来介绍这些属性。

## 3.1 绑定属性 ##

说到这个绑定属性，就不得不提起另外一个概念：轻进程（Light Weight Process，简称LWP）。轻进程和Linux系统的内核线程拥有相同的概念，属于内核的调度实体。一个轻进程可以控制一个或多个线程。默认情况下，对于一个拥有n个线程的程序，启动多少轻进程，由哪些轻进程来控制哪些线程由操作系统来控制，这种状态被称为非绑定的。那么绑定的含义就很好理解了，只要指定了某个线程“绑”在某个轻进程上，就可以称之为绑定的了。被绑定的线程具有较高的相应速度，因为操作系统的调度主体是轻进程，绑定线程可以保证在需要的时候它总有一个轻进程可用。绑定属性就是干这个用的。

设置绑定属性的接口是pthread\_attr\_setscope()，它的完整定义是：

int pthread\_attr\_setscope(pthread\_attr\_t \*attr, int scope);

它有两个参数，第一个就是线程属性对象的指针，第二个就是绑定类型，拥有两个取值：PTHREAD\_SCOPE\_SYSTEM（绑定的）和PTHREAD\_SCOPE\_PROCESS（非绑定的）。代码2演示了这个属性的使用。

**\[cpp\]**  [view plain][] [copy][view plain]

1.  \#include <stdio.h>  
2.  \#include <pthread.h>  
3.  ……  
4.  **int** main( **int** argc, **char** \*argv\[\] )  
5.  \{  
6.      pthread\_attr\_t attr;  
7.      pthread\_t th;  
8.      ……  
9.      pthread\_attr\_init( &attr );  
10.     pthread\_attr\_setscope( &attr, PTHREAD\_SCOPE\_SYSTEM );  
11.     pthread\_create( &th, &attr, **thread**, NULL );  
12.     ……  
13. \}

代码2设置线程绑定属性

不知道你是否在这里发现了本文的矛盾之处。就是这个绑定属性跟我们之前说的NPTL有矛盾之处。在介绍NPTL的时候就说过业界有一种m:n的线程方案，就跟这个绑定属性有关。但是笔者还说过NPTL因为Linux的“蠢”没有采取这种方案，而是采用了“1:1”的方案。这也就是说，Linux的线程永远都是绑定。对，Linux的线程永远都是绑定的，所以PTHREAD\_SCOPE\_PROCESS在Linux中不管用，而且会返回ENOTSUP错误。

既然Linux并不支持线程的非绑定，为什么还要提供这个接口呢？答案就是兼容！因为Linux的NTPL是号称POSIX标准兼容的，而绑定属性正是POSIX标准所要求的，所以提供了这个接口。如果读者们只是在Linux下编写多线程程序，可以完全忽略这个属性。如果哪天你遇到了支持这种特性的系统，别忘了我曾经跟你说起过这玩意儿：）

## 3.2 分离属性 ##

前面说过线程能够被合并和分离，分离属性就是让线程在创建之前就决定它应该是分离的。如果设置了这个属性，就没有必要调用pthread\_join()或pthread\_detach()来回收线程资源了。

设置分离属性的接口是pthread\_attr\_setdetachstate()，它的完整定义是：

**\[cpp\]**  [view plain][] [copy][view plain]

1.  pthread\_attr\_setdetachstat(pthread\_attr\_t \*attr, **int** detachstate);

它的第二个参数有两个取值：PTHREAD\_CREATE\_DETACHED（分离的）和PTHREAD\_CREATE\_JOINABLE（可合并的，也是默认属性）。代码3演示了这个属性的使用。

**\[cpp\]**  [view plain][] [copy][view plain]

代码3设置线程分离属性

## 3.3 调度属性 ##

线程的调度属性有三个，分别是：算法、优先级和继承权。

Linux提供的线程调度算法有三个：轮询、先进先出和其它。其中轮询和先进先出调度算法是POSIX标准所规定，而其他则代表采用Linux自己认为更合适的调度算法，所以默认的调度算法也就是其它了。轮询和先进先出调度算法都属于实时调度算法。轮询指的是时间片轮转，当线程的时间片用完，系统将重新分配时间片，并将它放置在就绪队列尾部，这样可以保证具有相同优先级的轮询任务获得公平的CPU占用时间；先进先出就是先到先服务，一旦线程占用了CPU则一直运行，直到有更高优先级的线程出现或自己放弃。

设置线程调度算法的接口是pthread\_attr\_setschedpolicy()，它的完整定义是：

pthread\_attr\_setschedpolicy(pthread\_attr\_t \*attr, int policy);

它的第二个参数有三个取值：SCHED\_RR（轮询）、SCHED\_FIFO（先进先出）和SCHED\_OTHER（其它）。

Linux的线程优先级与进程的优先级不一样，进程优先级我们后面再说。Linux的线程优先级是从1到99的数值，数值越大代表优先级越高。而且要注意的是，只有采用SHCED\_RR或SCHED\_FIFO调度算法时，优先级才有效。对于采用SCHED\_OTHER调度算法的线程，其优先级恒为0。

设置线程优先级的接口是pthread\_attr\_setschedparam()，它的完整定义是：

**\[cpp\]**  [view plain][] [copy][view plain]

1.  **struct** sched\_param \{  
2.      **int** sched\_priority;  
3.  \}  
4.  **int** pthread\_attr\_setschedparam(pthread\_attr\_t \*attr, **struct** sched\_param \*param);

sched\_param结构体的sched\_priority字段就是线程的优先级了。

此外，即便采用SCHED\_RR或SCHED\_FIFO调度算法，线程优先级也不是随便就能设置的。首先，进程必须是以root账号运行的；其次，还需要放弃线程的继承权。什么是继承权呢？就是当创建新的线程时，新线程要继承父线程（创建者线程）的调度属性。如果不希望新线程继承父线程的调度属性，就要放弃继承权。

设置线程继承权的接口是pthread\_attr\_setinheritsched()，它的完整定义是：

**\[cpp\]**  [view plain][] [copy][view plain]

1.  **int** pthread\_attr\_setinheritsched(pthread\_attr\_t \*attr, **int** inheritsched);

它的第二个参数有两个取值：PTHREAD\_INHERIT\_SCHED（拥有继承权）和PTHREAD\_EXPLICIT\_SCHED（放弃继承权）。新线程在默认情况下是拥有继承权。

代码4能够演示不同调度算法和不同优先级下各线程的行为，同时也展示如何修改线程的调度属性。

**\[cpp\]**  [view plain][] [copy][view plain]

1.  \#include <stdio.h>  
2.  \#include <unistd.h>  
3.  \#include <stdlib.h>  
4.  \#include <pthread.h>  
5.  \#define THREAD\_COUNT 12  
6.  **void** show\_thread\_policy( **int** threadno )  
7.  \{  
8.      **int** policy;  
9.      **struct** sched\_param param;  
10.     pthread\_getschedparam( pthread\_self(), &policy, ¶m );  
11.     **switch**( policy )\{  
12.     **case** SCHED\_OTHER:  
13.         printf( "SCHED\_OTHER %d\\n", threadno );  
14.         **break**;  
15.     **case** SCHED\_RR:  
16.         printf( "SCHDE\_RR %d\\n", threadno );  
17.         **break**;  
18.     **case** SCHED\_FIFO:  
19.         printf( "SCHED\_FIFO %d\\n", threadno );  
20.         **break**;  
21.     **default**:  
22.         printf( "UNKNOWN\\n");  
23.     \}  
24. \}  
25. **void**\* **thread**( **void** \*arg )  
26. \{  
27.     **int** i, j;  
28.     **long** threadno = (**long**)arg;  
29.     printf( "thread %d start\\n", threadno );  
30.     sleep(1);  
31.     show\_thread\_policy( threadno );  
32.     **for**( i = 0; i < 10; ++i ) \{  
33.         **for**( j = 0; j < 100000000; ++j )\{\}  
34.         printf( "thread %d\\n", threadno );  
35.     \}  
36.     printf( "thread %d exit\\n", threadno );  
37.     **return** NULL;  
38. \}  
39. **int** main( **int** argc, **char** \*argv\[\] )  
40. \{  
41.     **long** i;  
42.     pthread\_attr\_t attr\[THREAD\_COUNT\];  
43.     pthread\_t pth\[THREAD\_COUNT\];  
44.     **struct** sched\_param param;  
45.     **for**( i = 0; i < THREAD\_COUNT; ++i )  
46.         pthread\_attr\_init( &attr\[i\] );  
47.         **for**( i = 0; i < THREAD\_COUNT / 2; ++i ) \{  
48.             param.sched\_priority = 10;                    
49.             pthread\_attr\_setschedpolicy( &attr\[i\], SCHED\_FIFO );  
50.             pthread\_attr\_setschedparam( &attr\[i\], ¶m );  
51.             pthread\_attr\_setinheritsched( &attr\[i\], PTHREAD\_EXPLICIT\_SCHED );  
52.         \}  
53.         **for**( i = THREAD\_COUNT / 2; i < THREAD\_COUNT; ++i ) \{  
54.             param.sched\_priority = 20;                    
55.             pthread\_attr\_setschedpolicy( &attr\[i\], SCHED\_FIFO );  
56.             pthread\_attr\_setschedparam( &attr\[i\], ¶m );  
57.             pthread\_attr\_setinheritsched( &attr\[i\], PTHREAD\_EXPLICIT\_SCHED );  
58.         \}  
59.         **for**( i = 0; i < THREAD\_COUNT; ++i )                      
60.             pthread\_create( &pth\[i\], &attr\[i\], **thread**, (**void**\*)i );                
61.         **for**( i = 0; i < THREAD\_COUNT; ++i )                      
62.             pthread\_join( pth\[i\], NULL );                      
63.         **for**( i = 0; i < THREAD\_COUNT; ++i )                      
64.             pthread\_attr\_destroy( &attr\[i\] );                     
65.     **return** 0;                             
66. \}

代码4设置线程调度属性

这段代码中含有一些没有介绍过的接口，读者们可以使用Linux的联机帮助来查看它们的具体用法和作用。

## 3.4 堆栈大小属性 ##

从前面的这些例子中可以了解到，线程的主函数与程序的主函数main()有一个很相似的特性，那就是可以拥有局部变量。虽然同一个进程的线程之间是共享内存空间的，但是它的局部变量确并不共享。原因就是局部变量存储在堆栈中，而不同的线程拥有不同的堆栈。Linux系统为每个线程默认分配了8MB的堆栈空间，如果觉得这个空间不够用，可以通过修改线程的堆栈大小属性进行扩容。

修改线程堆栈大小属性的接口是pthread\_attr\_setstacksize()，它的完整定义为：

**\[cpp\]**  [view plain][] [copy][view plain]

1.  **int** pthread\_attr\_setstacksize(pthread\_attr\_t \*attr, **size\_t** stacksize);

它的第二个参数就是堆栈大小了，以字节为单位。需要注意的是，线程堆栈不能小于16KB，而且尽量按4KB(32位系统)或2MB（64位系统）的整数倍分配，也就是内存页面大小的整数倍。此外，修改线程堆栈大小是有风险的，如果你不清楚你在做什么，最好别动它（其实我很后悔把这么危险的东西告诉了你:）。

## 3.5 满栈警戒区属性 ##

既然线程是有堆栈的，而且还有大小限制，那么就一定会出现将堆栈用满的情况。线程的堆栈用满是非常危险的事情，因为这可能会导致对内核空间的破坏，一旦被有心人士所利用，后果也不堪设想。为了防治这类事情的发生，Linux为线程堆栈设置了一个满栈警戒区。这个区域一般就是一个页面，属于线程堆栈的一个扩展区域。一旦有代码访问了这个区域，就会发出SIGSEGV信号进行通知。

虽然满栈警戒区可以起到安全作用，但是也有弊病，就是会白白浪费掉内存空间，对于内存紧张的系统会使系统变得很慢。所有就有了关闭这个警戒区的需求。同时，如果我们修改了线程堆栈的大小，那么系统会认为我们会自己管理堆栈，也会将警戒区取消掉，如果有需要就要开启它。

修改满栈警戒区属性的接口是pthread\_attr\_setguardsize()，它的完整定义为：

**\[cpp\]**  [view plain][] [copy][view plain]

1.  **int** pthread\_attr\_setguardsize(pthread\_attr\_t \*attr, **size\_t** guardsize);

它的第二个参数就是警戒区大小了，以字节为单位。与设置线程堆栈大小属性相仿，应该尽量按照4KB或2MB的整数倍来分配。当设置警戒区大小为0时，就关闭了这个警戒区。

虽然栈满警戒区需要浪费掉一点内存，但是能够极大的提高安全性，所以这点损失是值得的。而且一旦修改了线程堆栈的大小，一定要记得同时设置这个警戒区。

# 4. 线程本地存储 #

内线程之间可以共享内存地址空间，线程之间的数据交换可以非常快捷，这是线程最显著的优点。但是多个线程访问共享数据，需要昂贵的同步开销，也容易造成与同步相关的BUG，更麻烦的是有些数据根本就不希望被共享，这又是缺点。可谓：“成也萧何，败也萧何”，说的就是这个道理。

C程序库中的errno是个最典型的一个例子。errno是一个全局变量，会保存最后一个系统调用的错误代码。在单线程环境并不会出现什么问题。但是在多线程环境，由于所有线程都会有可能修改errno，这就很难确定errno代表的到底是哪个系统调用的错误代码了。这就是有名的“非线程安全（Non Thread-Safe）”的。

此外，从现代技术角度看，在很多时候使用多线程的目的并不是为了对共享数据进行并行处理（在Linux下有更好的方案，后面会介绍）。更多是由于多核心CPU技术的引入，为了充分利用CPU资源而进行并行运算（不互相干扰）。换句话说，大多数情况下每个线程只会关心自己的数据而不需要与别人同步。

为了解决这些问题，可以有很多种方案。比如使用不同名称的全局变量。但是像errno这种名称已经固定了的全局变量就没办法了。在前面的内容中提到在线程堆栈中分配局部变量是不在线程间共享的。但是它有一个弊病，就是线程内部的其它函数很难访问到。目前解决这个问题的简便易行的方案是线程本地存储，即Thread Local Storage，简称TLS。利用TLS，errno所反映的就是本线程内最后一个系统调用的错误代码了，也就是线程安全的了。

Linux提供了对TLS的完整支持，通过下面这些接口来实现：

**\[cpp\]**  [view plain][] [copy][view plain]

1.  **int** pthread\_key\_create(pthread\_key\_t \*key, **void** (\*destructor)(**void**\*));  
2.  **int** pthread\_key\_delete(pthread\_key\_t key);  
3.  **void**\* pthread\_getspecific(pthread\_key\_t key);  
4.  **int** pthread\_setspecific(pthread\_key\_t key, **const** **void** \*value);

pthread\_key\_create()接口用于创建一个线程本地存储区。第一个参数用来返回这个存储区的句柄，需要使用一个全局变量保存，以便所有线程都能访问到。第二个参数是线程本地数据的回收函数指针，如果希望自己控制线程本地数据的生命周期，这个参数可以传递NULL。

pthread\_key\_delete()接口用于回收线程本地存储区。其唯一的参数就要回收的存储区的句柄。

pthread\_getspecific()和pthread\_setspecific()这个两个接口分别用于获取和设置线程本地存储区的数据。这两个接口在不同的线程下会有不同的结果不同（相同的线程下就会有相同的结果），这也就是线程本地存储的关键所在。

代码5展示了如何在Linux使用线程本地存储，注意执行结果，分析一下线程本地存储的一些特性,以及内存回收的时机。

**\[cpp\]**  [view plain][] [copy][view plain]

1.  \#include <stdio.h>  
2.  \#include <stdlib.h>  
3.  \#include <pthread.h>  
4.  \#define THREAD\_COUNT 10  
5.  pthread\_key\_t g\_key;  
6.  **typedef** **struct** thread\_data\{  
7.      **int** thread\_no;  
8.  \} thread\_data\_t;  
9.  **void** show\_thread\_data()  
10. \{  
11.     thread\_data\_t \*data = pthread\_getspecific( g\_key );  
12.     printf( "Thread %d \\n", data->thread\_no );  
13. \}  
14. **void**\* **thread**( **void** \*arg )  
15. \{  
16.     thread\_data\_t \*data = (thread\_data\_t \*)arg;  
17.     printf( "Start thread %d\\n", data->thread\_no );  
18.     pthread\_setspecific( g\_key, data );  
19.     show\_thread\_data();  
20.     printf( "Thread %d exit\\n", data->thread\_no );  
21. \}  
22. **void** free\_thread\_data( **void** \*arg )  
23. \{  
24.     thread\_data\_t \*data = (thread\_data\_t\*)arg;  
25.     printf( "Free thread %d data\\n", data->thread\_no );  
26.     free( data );  
27. \}  
28. **int** main( **int** argc, **char** \*argv\[\] )  
29. \{  
30.     **int** i;  
31.     pthread\_t pth\[THREAD\_COUNT\];  
32.     thread\_data\_t \*data = NULL;  
33.     pthread\_key\_create( &g\_key, free\_thread\_data );  
34.     **for**( i = 0; i < THREAD\_COUNT; ++i ) \{  
35.         data = malloc( **sizeof**( thread\_data\_t ) );  
36.         data->thread\_no = i;  
37.         pthread\_create( &pth\[i\], NULL, **thread**, data );  
38.     \}  
39.     **for**( i = 0; i < THREAD\_COUNT; ++i )  
40.         pthread\_join( pth\[i\], NULL );  
41.     pthread\_key\_delete( g\_key );  
42.     **return** 0;  
43. \}

代码5使用线程本地存储

# 5. 线程的同步 #

虽然线程本地存储可以避免线程访问共享数据，但是线程之间的大部分数据始终还是共享的。在涉及到对共享数据进行读写操作时，就必须使用同步机制，否则就会造成线程们哄抢共享数据的结果，这会把你的数据弄的七零八落理不清头绪。

Linux提供的线程同步机制主要有互斥锁和条件变量。其它形式的线程同步机制用得并不多，本书也不准备详细讲解，有兴趣的读者可以参考相关文档。

## 5.1 互斥锁 ##

首先我们看一下互斥锁。所谓的互斥就是线程之间互相排斥，获得资源的线程排斥其它没有获得资源的线程。Linux使用互斥锁来实现这种机制。

既然叫锁，就有加锁和解锁的概念。当线程获得了加锁的资格，那么它将独享这个锁，其它线程一旦试图去碰触这个锁就立即被系统“拍晕”。当加锁的线程解开并放弃了这个锁之后，那些被“拍晕”的线程会被系统唤醒，然后继续去争抢这个锁。至于谁能抢到，只有天知道。但是总有一个能抢到。于是其它来凑热闹的线程又被系统给“拍晕”了……如此反复。感觉线程的“头”很痛：）

从互斥锁的这种行为看，线程加锁和解锁之间的代码相当于一个独木桥，同意时刻只有一个线程能执行。从全局上看，在这个地方，所有并行运行的线程都变成了排队运行了。比较专业的叫法是同步执行，这段代码区域叫临界区。同步执行就破坏了线程并行性的初衷了，临界区越大破坏得越厉害。所以在实际应用中，应该尽量避免有临界区出现。实在不行，临界区也要尽量的小。如果连缩小临界区都做不到，那还使用多线程干嘛？

互斥锁在Linux中的名字是mutex。这个似乎优点眼熟。对，在前面介绍NPTL的时候提起过，但是那个叫futex，是系统底层机制。对于提供给用户使用的则是这个mutex。Linux初始化和销毁互斥锁的接口是pthread\_mutex\_init()和pthead\_mutex\_destroy()，对于加锁和解锁则有pthread\_mutex\_lock()、pthread\_mutex\_trylock()和pthread\_mutex\_unlock()。这些接口的完整定义如下：

**\[cpp\]**  [view plain][] [copy][view plain]

1.  **int** pthread\_mutex\_init(pthread\_mutex\_t \*restrict mutex,**const** pthread\_mutexattr\_t \*restrict attr);  
2.  **int** pthread\_mutex\_destory(pthread\_mutex\_t \*mutex );  
3.  **int** pthread\_mutex\_lock(pthread\_mutex\_t \*mutex);  
4.  **int** pthread\_mutex\_trylock(pthread\_mutex\_t \*mutex);  
5.  **int** pthread\_mutex\_unlock(pthread\_mutex\_t \*mutex);

从这些定义中可以看到，互斥锁也是有属性的。只不过这个属性在绝大多数情况下都不需要改动，所以使用默认的属性就行。方法就是给它传递NULL。

phtread\_mutex\_trylock()比较特别，用它试图加锁的线程永远都不会被系统“拍晕”，只是通过返回EBUSY来告诉程序员这个锁已经有人用了。至于是否继续“强闯”临界区，则由程序员决定。系统提供这个接口的目的可不是让线程“强闯”临界区的。它的根本目的还是为了提高并行性，留着这个线程去干点其它有意义的事情。当然，如果很幸运恰巧这个时候还没有人拥有这把锁，那么自然也会取得临界区的使用权。

代码6演示了在Linux下如何使用互斥锁。

**\[cpp\]**  [view plain][] [copy][view plain]

1.  \#include <stdio.h>  
2.  \#include <stdlib.h>  
3.  \#include <errno.h>  
4.  \#include <unistd.h>  
5.  \#include <pthread.h>  
6.  pthread\_mutex\_t g\_mutex;  
7.  **int** g\_lock\_var = 0;  
8.  **void**\* thread1( **void** \*arg )  
9.  \{  
10.     **int** i, ret;  
11.     **time\_t** end\_time;  
12.     end\_time = time(NULL) + 10;  
13.     **while**( time(NULL) < end\_time ) \{  
14.         ret = pthread\_mutex\_trylock( &g\_mutex );  
15.         **if**( EBUSY == ret ) \{  
16.             printf( "thread1: the varible is locked by thread2.\\n" );  
17.         \} **else** \{  
18.             printf( "thread1: lock the variable!\\n" );  
19.             ++g\_lock\_var;  
20.             pthread\_mutex\_unlock( &g\_mutex );  
21.         \}  
22.         sleep(1);  
23.     \}  
24.     **return** NULL;  
25. \}  
26. **void**\* thread2( **void** \*arg )  
27. \{  
28.     **int** i;  
29.     **time\_t** end\_time;  
30.     end\_time = time(NULL) + 10;  
31.     **while**( time(NULL) < end\_time ) \{  
32.         pthread\_mutex\_lock( &g\_mutex );  
33.         printf( "thread2: lock the variable!\\n" );  
34.         ++g\_lock\_var;  
35.         sleep(1);  
36.         pthread\_mutex\_unlock( &g\_mutex );  
37.     \}  
38.     **return** NULL;  
39. \}  
40. **int** main( **int** argc, **char** \*argv\[\] )  
41. \{  
42.     **int** i;  
43.     pthread\_t pth1,pth2;  
44.     pthread\_mutex\_init( &g\_mutex, NULL );  
45.     pthread\_create( &pth1, NULL, thread1, NULL );  
46.     pthread\_create( &pth2, NULL, thread2, NULL );  
47.     pthread\_join( pth1, NULL );  
48.     pthread\_join( pth2, NULL );  
49.     pthread\_mutex\_destroy( &g\_mutex );  
50.     printf( "g\_lock\_var = %d\\n", g\_lock\_var );  
51.     **return** 0;                              
52. \}

代码6使用互斥锁

最后需要补充一点，互斥锁在同一个线程内，没有互斥的特性。也就是说，线程不能利用互斥锁让系统将自己“拍晕”。解释这个现象的一个很好的理由就是，拥有锁的线程把自己“拍晕”了，谁还能再拥有这把锁呢？但是另外情况需要避免，就是两个线程已经各自拥有一把锁了，但是还想得到对方的锁，这个时候两个线程都会被“拍晕”。一旦这种情况发生，就谁都不能获得这个锁了，这种情况还有一个著名的名字——死锁。死锁是永远都要避免的事情，因为这是严重损人不利己的行为。

## 5.2 条件变量 ##

条件变量关键点在“变量”上。与锁的不同之处就是，当线程遇到这个“变量”，并不是类似锁那样的被系统给“拍晕”，而是根据“条件”来选择是否在那里等待。等待什么呢？等待允许通过的“信号”。这个“信号”是系统控制的吗？显然不是！它是由另外一个线程来控制的。

如果说互斥锁可以比作独木桥，那么条件变量这就好比是马路上的红绿灯。车辆遇到红绿灯肯定会根据“灯”的颜色来判断是否通行，毕竟红灯停绿灯行这个道理在幼儿园的时候老师就教了。那么谁来控制“灯”的颜色呢？一定是交警啊，至少你我都不敢动它（有人会说那是自动的，可是间隔多少时间变换也是交警设置不是？）。那么“车辆”和“交警”就是马路上的两类线程，大多数情况下都是“车”多“交警”少。

更深一步理解，条件变量是一种事件机制。由一类线程来控制“事件”的发生，另外一类线程等待“事件”的发生。为了实现这种机制，条件变量必须是共享于线程之间的全局变量。而且，条件变量也需要与互斥锁同时使用。

初始化和销毁条件变量的接口是pthread\_cond\_init()和pthread\_cond\_destory();控制“事件”发生的接口是pthread\_cond\_signal()或pthread\_cond\_broadcast()；等待“事件”发生的接口是pthead\_cond\_wait()或pthread\_cond\_timedwait()。它们的完整定义如下：

**\[cpp\]**  [view plain][] [copy][view plain]

1.  **int** pthread\_cond\_init(pthread\_cond\_t \*cond, **const** pthread\_condattr\_t \*attr);  
2.  **int** pthread\_cond\_destory(pthread\_cond\_t \*cond);  
3.  **int** pthread\_cond\_wait(pthread\_cond\_t \*cond, pthread\_mutex\_t \*mutex);  
4.  **int** pthread\_cond\_timedwait(pthread\_cond\_t \*cond,pthread\_mutex\_t \*mutex, **const** timespec \*abstime);  
5.  **int** pthread\_cond\_signal(pthread\_cond\_t \*cond);  
6.  **int** pthread\_cond\_broadcast(pthread\_cond\_t \*cond);

对于等待“事件”的接口从其名称中可以看出，一种是无限期等待，一种是限时等待。后者与互斥锁的pthread\_mutex\_trylock()有些类似，即当等待的“事件”经过一段时间之后依然没有发生，那就去干点别的有意义的事情去。而对于控制“事件”发生的接口则有“单播”和“广播”之说。所谓单播就是只有一个线程会得到“事件”已经发生了的“通知”，而广播就是所有线程都会得到“通知”。对于广播情况，所有被“通知”到的线程也要经过由互斥锁控制的独木桥。

对于条件变量的使用，可以参考代码7，它实现了一种生产者与消费者的线程同步方案。

**\[cpp\]**  [view plain][] [copy][view plain]

1.  \#include <stdio.h>  
2.  \#include <stdlib.h>  
3.  \#include <pthread.h>  
4.  \#define BUFFER\_SIZE 5  
5.  pthread\_mutex\_t g\_mutex;  
6.  pthread\_cond\_t g\_cond;  
7.  **typedef** **struct** \{  
8.      **char** buf\[BUFFER\_SIZE\];  
9.      **int** count;  
10. \} buffer\_t;  
11. buffer\_t g\_share = \{ "", 0\};  
12. **char** g\_ch = 'A';  
13. **void**\* producer( **void** \*arg )  
14. \{  
15.     printf( "Producer starting.\\n" );  
16.     **while**( g\_ch != 'Z' ) \{  
17.         pthread\_mutex\_lock( &g\_mutex );  
18.         **if**( g\_share.count < BUFFER\_SIZE ) \{  
19.             g\_share.buf\[g\_share.count++\] = g\_ch++;  
20.             printf( "Prodcuer got char\[%c\]\\n", g\_ch - 1 );  
21.             **if**( BUFFER\_SIZE == g\_share.count ) \{  
22.                 printf( "Producer signaling full.\\n" );  
23.                 pthread\_cond\_signal( &g\_cond );  
24.             \}  
25.         \}  
26.         pthread\_mutex\_unlock( &g\_mutex );  
27.     \}  
28.     printf( "Producer exit.\\n" );  
29.     **return** NULL;  
30. \}  
31. **void**\* consumer( **void** \*arg )  
32. \{  
33.     **int** i;  
34.     printf( "Consumer starting.\\n" );  
35.     **while**( g\_ch != 'Z' ) \{  
36.         pthread\_mutex\_lock( &g\_mutex );  
37.         printf( "Consumer waiting\\n" );  
38.         pthread\_cond\_wait( &g\_cond, &g\_mutex );  
39.         printf( "Consumer writing buffer\\n" );  
40.         **for**( i = 0; g\_share.buf\[i\] && g\_share.count; ++i ) \{  
41.             putchar( g\_share.buf\[i\] );  
42.             --g\_share.count;  
43.         \}  
44.         putchar('\\n');  
45.         pthread\_mutex\_unlock( &g\_mutex );  
46.     \}  
47.     printf( "Consumer exit.\\n" );  
48.     **return** NULL;  
49. \}  
50. **int** main( **int** argc, **char** \*argv\[\] )  
51. \{  
52.     pthread\_t ppth, cpth;  
53.     pthread\_mutex\_init( &g\_mutex, NULL );  
54.     pthread\_cond\_init( &g\_cond, NULL );  
55.     pthread\_create( &cpth, NULL, consumer, NULL );  
56.     pthread\_create( &ppth, NULL, producer, NULL );  
57.     pthread\_join( ppth, NULL );  
58.     pthread\_join( cpth, NULL );  
59.     pthread\_mutex\_destroy( &g\_mutex );  
60.     pthread\_cond\_destroy( &g\_cond );  
61.     **return** 0;  
62. \}

代码7使用条件变量

从代码中会发现，等待“事件”发生的接口都需要传递一个互斥锁给它。而实际上这个互斥锁还要在调用它们之前加锁，调用之后解锁。不单如此，在调用操作“事件”发生的接口之前也要加锁，调用之后解锁。这就面临一个问题，按照这种方式，等于“发生事件”和“等待事件”是互为临界区的。也就是说，如果“事件”还没有发生，那么有线程要等待这个“事件”就会阻止“事件”的发生。更干脆一点，就是这个“生产者”和“消费者”是在来回的走独木桥。但是实际的情况是，“消费者”在缓冲区满的时候会得到这个“事件”的“通知”，然后将字符逐个打印出来，并清理缓冲区。直到缓冲区的所有字符都被打印出来之后，“生产者”才开始继续工作。

为什么会有这样的结果呢？这就要说明一下pthread\_cond\_wait()接口对互斥锁做什么。答案是：解锁。pthread\_cond\_wait()首先会解锁互斥锁，然后进入等待。这个时候“生产者”就能够进入临界区，然后在条件满足的时候向“消费者”发出信号。当pthead\_cond\_wait()获得“通知”之后，它还要对互斥锁加锁，这样可以防止“生产者”继续工作而“撑坏”缓冲区。另外，“生产者”在缓冲区不满的情况下才能工作的这个限定条件是很有必要的。因为在pthread\_cond\_wait()获得通知之后，在没有对互斥锁加锁之前，“生产者”可能已经重新进入临界区了，这样“消费者”又被堵住了。也就是因为条件变量这种工作性质，导致它必须与互斥锁联合使用。

此外，利用条件变量和互斥锁，可以模拟出很多其它类型的线程同步机制，比如：event、semaphore等。本书不再多讲，有兴趣的读者可以参考其它著作。或自己根据它们的行为自己来模拟实现。

[view plain]: http://blog.csdn.net/jiajun2001/article/details/12624923#