学习笔记八之线程

ゝ一纸荒年。 2022-08-10 06:26 152阅读 0赞

[线程][Link 1]

目录[(?)][Link 2][\[+\]][Link 2]

前一段时间因为开题的事情一直耽搁了我搞Linux的进度，搞的我之前学的东西都遗忘了，很烦躁的说，现在抽个时间把之前所学的做个小节。文章内容主要总结于《Linux程序设计第3版》。

## **1.Linux进程与线程** ##

Linux进程创建一个新线程时，线程将拥有自己的栈（因为线程有自己的局部变量），但与它的创建者共享全局变量、文件描述符、信号句柄和当前目录状态。

Linux通过fork创建子进程与创建线程之间是有区别的：fork创建出该进程的一份拷贝，这个新进程拥有自己的变量和自己的PID，它的时间调度是独立的，它的执行几乎完全独立于父进程。

进程可以看成一个资源的基本单位，而线程是程序调度的基本单位，一个进程内部的线程之间共享进程获得的时间片。

## **2.\_REENTRANT宏** ##

在一个多线程程序里，默认情况下，只有一个errno变量供所有的线程共享。在一个线程准备获取刚才的错误代码时，该变量很容易被另一个线程中的函数调用所改变。类似的问题还存在于fputs之类的函数中，这些函数通常用一个单独的全局性区域来缓存输出数据。

为解决这个问题，需要使用可重入的例程。可重入代码可以被多次调用而仍然工作正常。编写的多线程程序，通过定义宏\_REENTRANT来告诉编译器我们需要可重入功能，这个宏的定义必须出现于程序中的任何\#include语句之前。

\_REENTRANT为我们做三件事情，并且做的非常优雅：

（1）它会对部分函数重新定义它们的可安全重入的版本，这些函数名字一般不会发生改变，只是会在函数名后面添加\_r字符串，如函数名gethostbyname变成gethostbyname\_r。

（2）stdio.h中原来以宏的形式实现的一些函数将变成可安全重入函数。

（3）在error.h中定义的变量error现在将成为一个函数调用，它能够以一种安全的多线程方式来获取真正的errno的值。

## **3.线程的基本函数** ##

大多数pthread\_XXX系列的函数在失败时，并未遵循UNIX函数的惯例返回-1，这种情况在UNIX函数中属于一少部分。如果调用成功，则返回值是0，如果失败则返回错误代码。

### 1.线程创建： ###

\#include <pthread.h>

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

参数说明：

thread：指向pthread\_create类型的指针，用于引用新创建的线程。

attr：用于设置线程的属性，一般不需要特殊的属性，所以可以简单地设置为NULL。

\*(\*start\_routine)(void \*)：传递新线程所要执行的函数地址。

arg：新线程所要执行的函数的参数。

调用如果成功，则返回值是0，如果失败则返回错误代码。

### 2.线程终止 ###

\#include <pthread.h>

void pthread\_exit(void \*retval);

参数说明：

retval：返回指针，指向线程向要返回的某个对象。

线程通过调用pthread\_exit函数终止执行，并返回一个指向某对象的指针。注意：绝不能用它返回一个指向局部变量的指针，因为线程调用该函数后，这个局部变量就不存在了，这将引起严重的程序漏洞。

### 3.线程同步 ###

\#include <pthread.h>

int pthread\_join(pthread\_t th, void \*\*thread\_return);

参数说明：

th：将要等待的张璐，线程通过pthread\_create返回的标识符来指定。

thread\_return：一个指针，指向另一个指针，而后者指向线程的返回值。

一个简单的多线程Demo（thread1.c）：

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

1.  \#include <pthread.h>  
2.  \#include <stdio.h>  
3.  \#include <stdlib.h>  
4.  \#include <string.h>  
5.    
6.  void \*thread\_function(void \*arg);  
7.    
8.  char message\[\] = "Hello World";  
9.    
10. int main()  
11. \{  
12.     int res;  
13.     pthread\_t a\_thread;  
14.     void \*thread\_result;  
15.   
16.     res = pthread\_create(&a\_thread, NULL, thread\_function, (void \*)message);  
17.     if (res != 0)  
18.     \{  
19.         perror("Thread creation failed!");  
20.         exit(EXIT\_FAILURE);  
21.     \}  
22.   
23.     printf("Waiting for thread to finish.../n");  
24.       
25.     res = pthread\_join(a\_thread, &thread\_result);  
26.     if (res != 0)  
27.     \{  
28.         perror("Thread join failed!/n");  
29.         exit(EXIT\_FAILURE);  
30.     \}  
31.   
32.     printf("Thread joined, it returned %s/n", (char \*)thread\_result);  
33.     printf("Message is now %s/n", message);  
34.   
35.     exit(EXIT\_FAILURE);  
36. \}  
37.   
38. void \*thread\_function(void \*arg)  
39. \{  
40.     printf("thread\_function is running. Argument was %s/n", (char \*)arg);  
41.     sleep(3);  
42.     strcpy(message, "Bye!");  
43.     pthread\_exit("Thank you for your CPU time!");  
44. \}

编译这个程序时，需要定义宏\_REENTRANT：

gcc -D\_REENTRANT thread1.c -o thread1 –lpthread

运行这个程序：

$ ./thread1输出：

thread\_function is running. Argument was Hello World

Waiting for thread to finish...

Thread joined, it returned Thank you for your CPU time!

Message is now Bye!

这个例子值得我们去花时间理解，因为它将作为几个例子的基础。

pthread\_exit(void \*retval)本身返回的就是指向某个对象的指针，因此，pthread\_join(pthread\_t th, void \*\*thread\_return);中的thread\_return是二级指针，指向线程返回值的指针。

可以看到，我们创建的新线程修改的数组message的值，而原先的线程也可以访问该数组。如果我们调用的是fork而不是pthread\_create，就不会有这样的效果了。原因是fork创建子进程之后，子进程会拷贝父进程，两者分离，相互不干扰，而线程之间则是共享进程的相关资源。

## **4.线程的同时执行** ##

接下来，我们来编写一个程序，以验证两个线程的执行是同时进行的。当然，如果是在一个单处理器系统上，线程的同时执行就需要靠CPU在线程之间的快速切换来实现了。

我们的程序需要利用一个原理：即除了局部变量外，所有其他的变量在一个进程中的所有线程之间是共享的。

在这个程序中，我们是在两个线程之间使用轮询技术，这种方式称为忙等待，所以它的效率会很低。在本文的后续部分，我们将介绍一种更好的解决办法。

下面的代码中，两个线程会不断的轮询判断flag的值是否满足各自的要求。

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

1.  \#include <pthread.h>  
2.  \#include <stdio.h>  
3.  \#include <stdlib.h>  
4.    
5.  int flag = 1;  
6.    
7.  void \*thread\_function(void \*arg);  
8.    
9.  int main()  
10. \{  
11.     int res;  
12.     pthread\_t a\_thread;  
13.     void \*thread\_result;  
14.     int count = 1;  
15.   
16.     res = pthread\_create(&a\_thread, NULL, thread\_function, NULL);  
17.     if (res != 0)  
18.     \{  
19.         perror("Thread creation failed");  
20.         exit(EXIT\_FAILURE);  
21.     \}  
22.   
23.     while (count++ <= 20)  
24.     \{  
25.         if (flag == 1)  
26.         \{  
27.             printf ("1");  
28.             flag = 2;  
29.         \}  
30.         else  
31.         \{  
32.             sleep(1);  
33.         \}  
34.     \}  
35.   
36.     printf("/nWaiting for thread to finish.../n");  
37.     res = pthread\_join(a\_thread, &thread\_result);  
38.     if (res != 0)  
39.     \{  
40.         perror("Thread join failed");  
41.         exit(EXIT\_FAILURE);  
42.     \}  
43.   
44.     exit(EXIT\_SUCCESS);  
45. \}  
46.   
47. void \*thread\_function(void \*arg)  
48. \{  
49.     int count = 1;  
50.   
51.     while (count++ <= 20)  
52.     \{  
53.         if (flag == 2)  
54.         \{  
55.             printf("2");  
56.             flag = 1;  
57.         \}  
58.         else  
59.         \{  
60.             sleep(1);  
61.         \}  
62.     \}  
63. \}

编译这个程序：

gcc -D\_REENTRANT thread2.c -o thread2 –lpthread

运行这个程序：

$ ./thread2

121212121212121212

Waiting for thread to finish...

## **5.线程的同步** ##

在上述示例中，我们采用轮询的方式在两个线程之间不停地切换是非常笨拙且没有效率的实现方式，幸运的是，专门有一级设计好的函数为我们提供更好的控制线程执行和访问代码临界区的方法。

本小节将介绍两个线程同步的基本方法：信号量和互斥量。这两种方法很相似，事实上，它们可以互相通过对方来实现。但在实际的应用中，对于一些情况，可能使用信号量或互斥量中的一个更符合问题的语义，并且效果更好。

### **5.1用信号量进行同步** ###

### 1.信号量创建 ###

\#include <semaphore.h>

int sem\_init(sem\_t \*sem, int pshared, unsigned int value);

参数说明：

sem：信号量对象。

pshared：控制信号量的类型，0表示这个信号量是当前进程的局部信号量，否则，这个信号量就可以在多个进程之间共享。

value：信号量的初始值。

#### 2.信号量控制 ####

\#include <semaphore.h>

int sem\_wait(sem\_t \*sem);

int sem\_post(sem\_t \*sem);

sem\_post的作用是以**原子操作**的方式给信号量的值加1。  
       sem\_wait的作用是以**原子操作**的方式给信号量的值减1，但它会等到信号量非0时才会开始减法操作。如果对值为0的信号量调用sem\_wait，这个函数就会等待，直到有线程增加了该信号量的值使其不再为0。

#### 3.信号量销毁 ####

\#include <semaphore.h>

int sem\_destory(sem\_t \*sem);

这个函数的作用是，用完信号量后对它进行清理，清理该信号量所拥有的资源。如果你试图清理的信号量正被一些线程等待，就会收到一个错误。

与大多数Linux函数一样，这些函数在成功时都返回0。

下面编码实现输入字符串，统计每行的字符个数，以“end”结束输入：

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

1.  \#include <pthread.h>  
2.  \#include <stdio.h>  
3.  \#include <stdlib.h>  
4.  \#include <string.h>  
5.  \#include <semaphore.h>  
6.    
7.  \#define SIZE 1024  
8.    
9.  void \*thread\_function(void \*arg);  
10.   
11. char buffer\[SIZE\];  
12. sem\_t sem;  
13.   
14. int main()  
15. \{  
16.     int res;  
17.     pthread\_t a\_thread;  
18.     void \*thread\_result;  
19.   
20.     res = sem\_init(&sem, 0, 0);  
21.     if (res != 0)  
22.     \{  
23.         perror("Sem init failed");  
24.         exit(EXIT\_FAILURE);  
25.     \}  
26.   
27.     res = pthread\_create(&a\_thread, NULL, thread\_function, NULL);  
28.     if (res != 0)  
29.     \{  
30.         perror("Thread create failed");  
31.         exit(EXIT\_FAILURE);  
32.     \}  
33.   
34.     printf("Input some text. Enter 'end' to finish/n");  
35.   
36.     while (scanf("%s", buffer))  
37.     \{  
38.         sem\_post(&sem);  
39.         if (strncmp("end", buffer, 3) == 0)  
40.             break;  
41.     \}  
42.   
43.     printf ("/nWaiting for thread to finish.../n");  
44.   
45.     res = pthread\_join(a\_thread, &thread\_result);  
46.     if (res != 0)  
47.     \{  
48.         perror("Thread join failed");  
49.         exit(EXIT\_FAILURE);  
50.     \}  
51.   
52.     printf ("Thread join/n");  
53.   
54.     sem\_destroy(&sem);  
55.   
56.     exit(EXIT\_SUCCESS);  
57. \}  
58.   
59. void \*thread\_function(void \*arg)  
60. \{  
61.     sem\_wait(&sem);  
62.     while (strncmp("end", buffer, 3) != 0)  
63.     \{  
64.         printf("You input %d characters/n", strlen(buffer));  
65.         sem\_wait(&sem);  
66.     \}  
67.     pthread\_exit(NULL);  
68. \}

编译这个程序：

gcc -D\_REENTRANT thread2.c -o thread2 –lpthread

运行这个程序：

$ ./thread3

Input some text. Enter 'end' to finish

123

You input 3 characters

1234

You input 4 characters

12345

You input 5 characters

end

Waiting for thread to finish…

Thread join

通过使用信号量，我们阻塞了统计字符个数的线程，这个程序似乎对快速的文本输入和悠闲的暂停都很适用，比之前的轮询解决方案效率上有了本质的提高。

### **5.2用互斥量进行线程同步** ###

另一种用在多线程程序中同步访问的方法是使用互斥量。它允许程序员锁住某个对象，使得每次只能有一个线程访问它。为了控制对关键代码的访问，必须在进入这段代码之前锁住一个互斥量，然后在完成操作之后解锁它。

用于互斥量的基本函数和用于信号量的函数非常相似：

\#include <pthread.h>

int pthread\_mutex\_init(pthread\_mutex\_t \*mutex, const pthread\_mutexattr\_t, \*mutexattr);

int pthread\_mutex\_lock(pthread\_mutex\_t \*mutex);

int pthread\_mutex\_unlock(pthread\_mutex\_t \*mutex);

int pthread\_mutex\_destory(pthread\_mutex\_t \*mutex);

与其他函数一样，成功时返回0，失败时将返回错误代码，但这些函数并不设置errno，所以必须对函数的返回代码进行检查。互斥量的属性设置这里不讨论，因此设置成NULL。

我们用互斥量来重写刚才的代码如下：

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

1.  \#include <pthread.h>  
2.  \#include <stdio.h>  
3.  \#include <stdlib.h>  
4.  \#include <string.h>  
5.  \#include <semaphore.h>  
6.    
7.  \#define SIZE 1024  
8.  char buffer\[SIZE\];  
9.    
10. void \*thread\_function(void \*arg);  
11. pthread\_mutex\_t mutex;  
12.   
13. int main()  
14. \{  
15.     int res;  
16.     pthread\_t a\_thread;  
17.     void \*thread\_result;  
18.   
19.     res = pthread\_mutex\_init(&mutex, NULL);  
20.     if (res != 0)  
21.     \{  
22.         perror("Mutex init failed!");  
23.         exit(EXIT\_FAILURE);  
24.     \}  
25.   
26.     res = pthread\_create(&a\_thread, NULL, thread\_function, NULL);  
27.     if (res != 0)  
28.     \{  
29.         perror("Thread create failed!");  
30.         exit(EXIT\_FAILURE);  
31.     \}  
32.   
33.     printf("Input some text. Enter 'end' to finish/n");  
34.   
35.     while (1)  
36.     \{  
37.         pthread\_mutex\_lock(&mutex);  
38.         scanf("%s", buffer);  
39.         pthread\_mutex\_unlock(&mutex);  
40.         if (strncmp("end", buffer, 3) == 0)  
41.             break;  
42.         sleep(1);  
43.     \}  
44.   
45.     res = pthread\_join(a\_thread, &thread\_result);  
46.     if (res != 0)  
47.     \{  
48.         perror("Thread join failed!");  
49.         exit(EXIT\_FAILURE);  
50.     \}  
51.   
52.     printf("Thread joined/n");  
53.   
54.     pthread\_mutex\_destroy(&mutex);  
55.   
56.     exit(EXIT\_SUCCESS);  
57. \}  
58.   
59. void \*thread\_function(void \*arg)  
60. \{  
61.     sleep(1);  
62.   
63.     while (1)  
64.     \{  
65.         pthread\_mutex\_lock(&mutex);  
66.         printf("You input %d characters/n", strlen(buffer));  
67.         pthread\_mutex\_unlock(&mutex);  
68.         if (strncmp("end", buffer, 3) == 0)  
69.             break;  
70.         sleep(1);  
71.     \}  
72. \}

编译这个程序：

gcc -D\_REENTRANT thread4.c -o thread4 –lpthread

运行这个程序：

$ ./thread4

Input some text. Enter 'end' to finish

123

You input 3 characters

1234

You input 4 characters

12345

You input 5 characters

end

You input 3 characters

Thread joined

## **6.线程的属性** ##

之前我们并未谈及到线程的属性，可以控制的线程属性是非常多的，这里面只列举一些常用的。

如在前面的示例中，我们都使用的pthread\_join同步线程，但其实有些情况下，我们并不需要。如：主线程为服务线程，而第二个线程为数据备份线程，备份工作完成之后，第二个线程可以直接终止了，它没有必要再返回到主线程中。因此，我们可以创建一个“脱离线程”。

下面介绍几个常用的函数：

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

功能：对线程属性变量的初始化。

attr：线程属性。

函数返回值：成功：0，失败：-1

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

功能：设置线程绑定属性。

attr：线程属性。

scope：PTHREAD\_SCOPE\_SYSTEM(绑定)；PTHREAD\_SCOPE\_PROCESS(非绑定)

函数返回值：成功：0，失败：-1

(3) int pthread\_attr\_setdetachstate (pthread\_attr\_t\* attr, int detachstate);

功能：设置线程分离属性。

attr：线程属性。

detachstate：PTHREAD\_CREATE\_DETACHED(分离)；PTHREAD\_CREATE\_JOINABLE（非分离）

函数返回值：成功：0，失败：-1

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

功能：设置创建线程的调度策略。

attr：线程属性；

policy：线程调度策略：SCHED\_FIFO、SCHED\_RR和SCHED\_OTHER。

函数返回值：成功：0，失败：-1

(5) int pthread\_attr\_setschedparam (pthread\_attr\_t\* attr, struct sched\_param\* param);

功能：设置线程优先级。

attr：线程属性。

param：线程优先级。

函数返回值：成功：0，失败：-1

(6) int pthread\_attr\_destroy (pthread\_attr\_t\* attr);

功能：对线程属性变量的销毁。

attr：线程属性。

函数返回值：成功：0，失败：-1

(7)其他

int pthread\_attr\_setguardsize(pthread\_attr\_t\* attr,size\_t guardsize);//设置新创建线程栈的保护区大小。

int pthread\_attr\_setinheritsched(pthread\_attr\_t\* attr, int inheritsched);//决定怎样设置新创建线程的调度属性。

int pthread\_attr\_setstack(pthread\_attr\_t\* attr, void\* stackader,size\_t stacksize);//两者共同决定了线程栈的基地址以及堆栈的最小尺寸（以字节为单位）。

int pthread\_attr\_setstackaddr(pthread\_attr\_t\* attr, void\* stackader);//决定了新创建线程的栈的基地址。

int pthread\_attr\_setstacksize(pthread\_attr\_t\* attr, size\_t stacksize);//决定了新创建线程的栈的最小尺寸（以字节为单位）。

例：创建优先级为10的线程。

pthread\_attr\_t attr;

struct sched\_param param;

pthread\_attr\_init(&attr);

pthread\_attr\_setscope (&attr, PTHREAD\_SCOPE\_SYSTEM); //绑定

pthread\_attr\_setdetachstate (&attr, PTHREAD\_CREATE\_DETACHED); //分离

pthread\_attr\_setschedpolicy(&attr, SCHED\_RR);

param.sched\_priority = 10;

pthread\_attr\_setschedparam(&attr, &param);

pthread\_create(xxx, &attr, xxx, xxx);

pthread\_attr\_destroy(&attr);

下面实现一个脱离线程的程序，创建一个线程，其属性设置为脱离状态。子线程结束时，要使用pthread\_exit，原来的主线程不再等待与子线程重新合并。代码如下：

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

1.  \#include <stdio.h>  
2.  \#include <unistd.h>  
3.  \#include <stdlib.h>  
4.  \#include <pthread.h>  
5.    
6.  void \*thread\_function(void \*arg);  
7.    
8.  char message\[\] = "Hello World";  
9.  int thread\_finished = 0;  
10.   
11. int main()  
12. \{  
13.     int res;  
14.     pthread\_t a\_thread;  
15.     pthread\_attr\_t thread\_attr;  
16.       
17.     res = pthread\_attr\_init(&thread\_attr);  
18.     if (res != 0)  
19.     \{  
20.         perror("Attribute creation failed");  
21.         exit(EXIT\_FAILURE);  
22.     \}  
23.       
24.     res = pthread\_attr\_setdetachstate(&thread\_attr, PTHREAD\_CREATE\_DETACHED);  
25.     if (res != 0)  
26.     \{  
27.         perror("Setting detached attribute failed");  
28.         exit(EXIT\_FAILURE);  
29.     \}  
30.       
31.     res = pthread\_create(&a\_thread, &thread\_attr, thread\_function, (void\*)message);  
32.     if (res != 0)  
33.     \{  
34.         perror("Thread creation failed");  
35.         exit(EXIT\_FAILURE);  
36.     \}  
37.       
38.     pthread\_attr\_destroy(&thread\_attr);  
39.     while(!thread\_finished)  
40.     \{  
41.         printf("Waiting for thread to say it's finished.../n");  
42.         sleep(1);  
43.     \}  
44.       
45.     printf("Other thread finished, bye!/n");  
46.     exit(EXIT\_SUCCESS);  
47. \}  
48.   
49. void \*thread\_function(void \*arg)  
50. \{  
51.     printf("thread\_function is running. Argument was %s/n", (char \*)arg);  
52.     sleep(4);  
53.     printf("Second thread setting finished flag, and exiting now/n");  
54.     thread\_finished = 1;  
55.     pthread\_exit(NULL);  
56. \}

编译这个程序：

gcc -D\_REENTRANT thread5.c -o thread5 –lpthread

运行这个程序：

$ ./thread5

thread\_function is running. Argument: hello world!

Waiting for thread to finished...

Second thread setting finished flag, and exiting now

Other thread finished!

通过设置线程的属性，我们还可以控制线程的调试，其方式与设置脱离状态是一样的。

## **7.取消一个线程** ##

有时，我们想让一个线程可以要求另一个线程终止，线程有方法做到这一点，与信号处理一样，线程可以在被要求终止时改变其行为。

先来看用于请求一个线程终止的函数：

\#include <pthread.h>

int pthread\_cancel(pthread\_t thread);

这个函数简单易懂，提供一个线程标识符，我们就可以发送请求来取消它。

线程可以用pthread\_setcancelstate设置自己的取消状态。

\#include <pthread.h>

int pthread\_setcancelstate(int state, int \*oldstate);

参数说明：

state：可以是PTHREAD\_CANCEL\_ENABLE允许线程接收取消请求，也可以是PTHREAD\_CANCEL\_DISABLE忽略取消请求。

oldstate：获取先前的取消状态。如果对它没兴趣，可以简单地设置为NULL。如果取消请求被接受了，线程可以进入第二个控制层次，用pthread\_setcanceltype设置取消类型。

\#include <pthread.h>

int pthread\_setcanceltype(int type, int \*oldtype);

参数说明：

type：可以取PTHREAD\_CANCEL\_ASYNCHRONOUS，它将使得在接收到取消请求后立即采取行动；另一个是PTHREAD\_CANCEL\_DEFERRED，它将使得在接收到取消请求后，一直等待直到线程执行了下述函数之一后才采取行动：pthread\_join、pthread\_cond\_wait、pthread\_cond\_timedwait、pthread\_testcancel、sem\_wait或sigwait。

oldtype：允许保存先前的状态，如果不想知道先前的状态，可以传递NULL。

默认情况下，线程在启动时的取消状态为PTHREAD\_CANCEL\_ENABLE，取消类型是PTHREAD\_CANCEL\_DEFERRED。

下面编写代码thread6.c，主线程向它创建的线程发送一个取消请求。

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

1.  \#include <pthread.h>  
2.  \#include <stdio.h>  
3.  \#include <stdlib.h>  
4.    
5.  void \*thread\_function(void \*arg);  
6.    
7.  int main()  
8.  \{  
9.      int res;  
10.     pthread\_t a\_thread;  
11.     void \*thread\_result;  
12.   
13.     res = pthread\_create(&a\_thread, NULL, thread\_function, NULL);  
14.     if (res != 0)  
15.     \{  
16.         perror("Thread create failed!");  
17.         exit(EXIT\_FAILURE);  
18.     \}  
19.   
20.     sleep(4);  
21.     printf("Canceling thread.../n");  
22.   
23.     res = pthread\_cancel(a\_thread);  
24.     if (res != 0)  
25.     \{  
26.         perror("Thread cancel failed!");  
27.         exit(EXIT\_FAILURE);  
28.     \}  
29.   
30.     printf ("Waiting for thread to finished.../n");  
31.       
32.     res = pthread\_join(a\_thread, &thread\_result);  
33.     if (res != 0)  
34.     \{  
35.         perror ("Thread join failed!");  
36.         exit(EXIT\_FAILURE);  
37.     \}  
38.   
39.     printf("Thread canceled!");  
40.   
41.     exit(EXIT\_FAILURE);  
42. \}  
43.   
44. void \*thread\_function(void \*arg)  
45. \{  
46.     int i;  
47.     int res;  
48.   
49.     res = pthread\_setcancelstate(PTHREAD\_CANCEL\_ENABLE, NULL);  
50.     if (res != 0)  
51.     \{  
52.         perror("Thread setcancelstate failed!");  
53.         exit(EXIT\_FAILURE);  
54.     \}  
55.   
56.     res = pthread\_setcanceltype(PTHREAD\_CANCEL\_DEFERRED, NULL);  
57.     if (res != 0)  
58.     \{  
59.         perror("Thread setcanceltype failed!");  
60.         exit(EXIT\_FAILURE);  
61.     \}  
62.   
63.     printf("thread\_function is running.../n");  
64.   
65.     for (i = 0; i < 10; i++)  
66.     \{  
67.         printf("Thread is still running (%d).../n", i);  
68.         sleep(1);  
69.     \}  
70.     pthread\_exit(0);  
71. \}

编译这个程序：

gcc -D\_REENTRANT thread6.c -o thread6 –lpthread

运行这个程序：

$ ./thread6

thread\_function is running...

Thread is still running (0)...

Thread is still running (1)...

Thread is still running (2)...

Thread is still running (3)...

Canceling thread...

Waiting for thread to finished...

**8.多线程**

之前，我们所编写的代码里面都仅仅是创建了一个线程，现在我们来演示一下如何创建一个多线程的程序。

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

1.  \#include <pthread.h>  
2.  \#include <stdio.h>  
3.  \#include <stdlib.h>  
4.    
5.  \#define NUM 6  
6.    
7.  void \*thread\_function(void \*arg);  
8.    
9.  int main()  
10. \{  
11.     int res;  
12.     pthread\_t a\_thread\[NUM\];  
13.     void \*thread\_result;  
14.     int index;  
15.   
16.     for (index = 0; index < NUM; ++index) \{  
17.         res = pthread\_create(&a\_thread\[index\], NULL, thread\_function, (void \*)index);  
18.         if (res != 0)  
19.         \{  
20.             perror("Thread create failed!");  
21.             exit(EXIT\_FAILURE);  
22.         \}  
23.         sleep(1);  
24.     \}  
25.   
26.     printf("Waiting for threads to finished.../n");  
27.   
28.     for (index = NUM - 1; index >= 0; --index)  
29.     \{  
30.         res = pthread\_join(a\_thread\[index\], &thread\_result);  
31.         if (res == 0)  
32.         \{  
33.             printf("Picked up a thread:%d/n", index + 1);  
34.         \}  
35.         else  
36.         \{  
37.             perror("pthread\_join failed/n");  
38.         \}  
39.     \}  
40.   
41.     printf("All done/n");  
42.       
43.     exit(EXIT\_SUCCESS);  
44. \}  
45.   
46. void \*thread\_function(void \*arg)  
47. \{  
48.     int my\_number = (int)arg;  
49.     int rand\_num;  
50.   
51.     printf("thread\_function is running. Argument was %d/n", my\_number);  
52.     rand\_num = 1 + (int)(9.0 \* rand()/(RAND\_MAX + 1.0));  
53.     sleep(rand\_num);  
54.     printf("Bye from %d/n", my\_number);  
55.     pthread\_exit(NULL);  
56. \}

编译这个程序：

gcc -D\_REENTRANT thread7.c -o thread7 –lpthread

运行这个程序：

$ ./thread7

thread\_function is running. Argument was 0

thread\_function is running. Argument was 1

thread\_function is running. Argument was 2

thread\_function is running. Argument was 3

thread\_function is running. Argument was 4

Bye from 1

thread\_function is running. Argument was 5

Waiting for threads to finished...

Bye from 5

Picked up a thread:6

Bye from 0

Bye from 2

Bye from 3

Bye from 4

Picked up a thread:5

Picked up a thread:4

Picked up a thread:3

Picked up a thread:2

Picked up a thread:1

All done

## **9.小结** ##

本文主要介绍了Linux环境下的多线程编程，介绍了信号量和互斥量、线程属性控制、线程同步、线程终止、取消线程及多线程并发。

本文比较简单，只作为初学Linux多线程编程入门之用。

[Link 1]: http://www.csdn.net/tag/%e7%ba%bf%e7%a8%8b
[Link 2]: http://blog.csdn.net/cqkxboy168/article/details/9132121#
[view plain]: http://blog.csdn.net/MONKEY_D_MENG/article/details/5628663#