Linux的多任务编程-线程

1.线程的基本概念

Linux操作系统很早就具备这些多进程功能了.但有时人们认为用fork()来创建一个新进程的代价还是太大,如在Web服务器中,通常采取的多进程方案是一旦接收到访问请求后,即创建一个新的进程,由该进程执行任务,当任务执行完毕后,该进程退出.如果有大量的请求在很短的时间中频繁的访问该服务器,那么服务器耗费在创建进程,销毁进程中的机时便十分可观.如果能用线程来完成这个工作,则情况会好很多.

线程的出现使得程序有了多个控制流程,能够在单进程的环境中执行多个任务.有了线程之后,一个进程就能够做不止一件事情.这使得程序复杂化了,但是这样做有很多优点:

• 同一进程内的线程共享该进程的资源,线程创建时无需复制这些资源,因此大大减少了上下文切换的开销;
• 由于地址空间的共享,使得内存和文件描述符的共享比多进程环境下要容易实现;
• 通过为每种事务的类型分配单独的处理线程,能够简化处理复杂事件的代码.
• 在交互式程序中使用多线程能很好的改善操作的响应时间,有更好的交互友好性.

就像每个进程有一个PID一样,每个线程有一个线程ID.但线程ID只是在它所属的进程环境中有效,因此在不同的进程中可能会找到两个具有相同线程ID的线程.线程ID通过数据类型pthread_t来表示.这个类型通常采用结构体来实现,因此在使用时与PID有较大的不同.例如必须使用下面的函数来比较两个线程ID.

[cpp]  view plain copy print ?

1. #include <pthread.h>  
2. int pthread_equal (pthread_t tid1, pthread_t tid2);   

与getpid函数类似,在线程中获取自身的线程ID的函数是:

[cpp]  view plain copy print ?

1. #include <pthread.h>  
2. pthread_t pthread_self (void);   

上面给出的这两个函数都有一个前缀"pthread_".事实上,与线程有关的函数库构成了一个完整的系列,绝大多数函数的名字都是以"pthread_"打头的.为了使用这些函数库,首先必须包含头文件<pthread.h>,其次在链接这些线程函数库时要使用编译器命令的"-pthread"选项.

2.线程的创建

创建一个新的线程可以通过调用pthread_create()函数来创建.该函数的原型是:

[plain]  view plain copy print ?

1. #include <pthread.h>  
2. int pthread_create (pthread_t *thread, pthread_attr_t *attr, void *(*start_rtn)(void), void *restrict arg);   

pthread_create()函数的第二个参数（pthread_attr_t *attr）表示线程的属性.如果该值设为NULL,就是采用默认属性,线程的多项属性都是可以更改的.这些属性主要包括绑定属性,离属性,堆栈地址,堆栈大小以及优先级.其中系统默认的属性为非绑定,非分离,缺省1M的堆栈以及与父进程同样级别的优先级.

最后的两个参数分别是线程将要启动执行的函数以及将要传递给这个函数的参数.如果传递的参数不止一个,那么需要把这些参数放在一个结构体中,然后把这个结构体的地址作为arg参数传入.

下面是一个简单的例子.

[cpp]  view plain copy print ?

1. #include <pthread.h>  
2. #include <stdio.h>  
3. #include <stdlib.h>  
4. #include <unistd.h>  
5. #include <sys/types.h>  
6.   
7. void print_ids (const char *s)  
8. {  
9.     pid_t       pid;  
10.     pthread_t   tid;  
11.     pid = getpid();  
12.     tid = pthread_self();  
13.       
14.     printf("%s pid %u tid %u (0x%x)\n", s,\  
15.         (unsigned int)pid,(unsigned int)tid,\  
16.         (unsigned int)tid);  
17. }  
18.   
19. void *thread_func(void *arg)  
20. {  
21.     print_ids("new thread: ");  
22.     printf("thread param is :%d\n",*(int *)arg);  
23.     return NULL;  
24. }  
25.   
26. int main(void)  
27. {  
28.   
29.     int err;  
30.     pthread_t newtid;  
31.     int myarg;  
32.     myarg=1;  
33.     err = pthread_create (&newtid, NULL, thread_func, &myarg);  
34.     if (err != 0)  
35.     {  
36.         perror("create thread error");  
37.         exit(1);  
38.     }  
39.     print_ids("main thread:");  
40.     sleep(1);  
41.     exit(0);  
42. }  

可以看到新创建的线程和主进程拥有相同的线程ID(PID均为1785),而线程ID显示不同的.

3.线程的终止

单个线程可以通过三种方式退出执行:

• 从启动例程中返回；
• 在线程内调用pthread_exit()函数;
• 被同一进程中的其他线程取消.

与在进程中使用exit和_exit函数退出类似,使用pthread_exit函数退出线程将返回一个退出状态码,并将保存对对线程调用pthread_join函数(类似于waitpid函数).这两个函数的原型如下:

[plain]  view plain copy print ?

1. #include <pthread.h>  
2. void pthread_exit (void *rval_ptr);  
3. int pthread_join (pthread_t thread , void **rval_ptr);  

    参数rval_ptr是一个无类型的指针,如果线程只是从它的启动例程返回,rval_ptr将包含返回码,如果线程被取消(在返回前被中止),由rval_ptr指定的内存单元就置为PTHREAD_CANCELLED.
    pthread_join函数的第一个参数指定了将要等待的线程ID,它就是pthread_creat函数返回的标识符.这个函数在成功时返回0,失败时返回一个错误代码,与pthread_creat函数类似.下面是一个简单的例子,用来熟悉函数的用法.

[plain]  view plain copy print ?

1. #include <stdio.h>  
2. #include <stdlib.h>  
3. #include <pthread.h>  
4.   
5. void *thread1(void *arg)  
6. {  
7.     printf("thread1 returning\n");  
8.     return ((void *)1);  
9. }  
10.   
11. void *thread2(void *arg)  
12. {  
13.     printf("thread2 exiting\n");  
14.     pthread_exit ((void *)2);  
15. }  
16.   
17. int main(void)  
18. {  
19.     int err;  
20.     pthread_t tid1,tid2;  
21.     void *tret;  
22.   
23.     err = pthread_create (&tid1, NULL, thread1, NULL);  
24.     if (err != 0)  
25.     {  
26.         perror("create thread1 error");  
27.         exit(1);  
28.     }  
29.     err = pthread_create (&tid2, NULL, thread2, NULL);  
30.     if (err != 0)  
31.     {  
32.         perror("create thread2 error");  
33.         exit(1);  
34.     }  
35.     err = pthread_join(tid1, &tret);  
36.     if (err != 0)  
37.     {  
38.         perror("join thread1 error");  
39.         exit(1);  
40.     }  
41.     printf("The exit code of thread1 :%d\n",(int)tret);  
42.     err = pthread_join(tid2, &tret);  
43.     if (err != 0)  
44.     {  
45.         perror("join thread2 error");  
46.         exit(1);  
47.     }  
48.     printf("The exit code of thread2 :%d\n",(int)tret);  
49.     exit(0);  
50. }  

从运行结果可以看出,当一个线程通过pthread_exit函数退出或者简单地使用return从启动例程中返回,进程中的其他线程可以通过pthread_join函数获得该线程的退出状态.需要注意的是参数rval_ptr所使用的内存在函数调用完后应该仍能是有效的,否则会出现无效或者非法内存访问错误.
线程还可以通过pthread_cancel函数来请求同一进程中的其他线程,该函数的原型如下:

[plain]  view plain copy print ?

1. <span style="font-size:18px;">#include <pthread.h>  
2. int pthread_calcel ( pthread_ t tid);</span>  

该函数并不像pthread_exit函数那样,强迫线程退出,而只是提出一个要求,至于被要求的线程,既可以接受请求退出执行,也可以忽略该请求继续执行.这个问题涉及到线程属性的设置,在后面我们会详细讲解.
线程和进程的函数有很多相似之处,下图总结了这些相似的函数.

到目前为止,我们所讨论的线程都是一种被称为"非分离状态"的线程.所谓"非分离线程",就是线程的一种属性,用来决定线程与什么杨的方式终止自己."非分离状态"的线程结束时,它所占用的系统资源并没有被释放,只有当pthread_join函数返回时,创建的线程才能释放自己占用的系统资源;而"分离状态"的线程,在线程结束时则立即释放所占用的系统资源.
下面我们来详细线程的属性设置.

4.线程的基本属性

对大多数程序来说,使用默认的属性就可以了,但有的属性还是十分有用的,所以有必要了解一些线程的这些属性的意义.
分离(Detachedstate)属性:如果不需要理解线程的终止状态,则可以修改这个属性为PTHREAD_CREATE_DETACHED,让线程以分离状态启动,当线程退出时收回它所占有的资源.如果没有同步措施,一个刚创建的分析线程有可能在pthread_creat函数返回之前就终止了,而它的线程标识符则被另一个新线程所使用.默认的PTHREAD_CREATE_JOIN表示非分离状态,可以用pthread_join函数来检查线程的退出状态.
绑定(Scope)属性:linux中采用"一对一"的线程机制,也就是一个用户线程对应一个内核线程.默认情况下,启动多少内核线程,哪些内核线程是由系统控制的,这种状况即非绑定的.而绑定状况是指一个用户线程固定的分配给一个内核线程,被绑定的线程具有较高的响应速度.通过设置绑定属性可以使得绑定的线程满足诸如实时之类的要求.
堆栈大小(Stack Size)属性:该属性定义了线程的堆栈大小,在大多数情况下,默认值是最合适的.
调度策略(Schedpolicy)属性:这个属性控制着由POSIX标准定义的调度策略,包括SCHED_FIFO(先入先出),SCHED_RR(循环),SCHED_OTHER(默认调度策略).
并发度(Concurrency)属性:并发度控制着用户线程可以映射到的内核线程的数目.在一个进程中,可能需要多个非绑定的线程被同时激活,默认情况下,线程库保证有足够多的线程处在激活状态下,以确保进程的运行.尽管这样可以节省系统资源,但那并不一定能达到最有效的并发性.

线程的属性大多通过pthread_attr_t结构来描述,通过修改pthread_attr_t结构来修改想成的默认属性.设置线程属性需要用到一对函数,它们是:

[plain]  view plain copy print ?

1. #include <pthread.h>  
2. int pthread_attr_init (pthread_attr_t *attr);  
3. int pthread_attr_destroy (pthread_attr_t *attr);  

使用pthread_attr_init函数初始化pthread_attr_t结构,之后pthread_attr_t结构中所包含的内容就是OS实现支持线程的所有属性的默认值,如果要修改其中个别属性的值,则需要调用其他的函数.

如果要去除对pthread_attr_t结构的初始化,可以调用pthread_attr_destroy函数,该函数将释放该空间的内存结构,同时用无效的值初始化该属性对象,因此如果该属性对象被无用,将会导致pthread_create函数返回错误.

不要尝试直接操作pthread_attr_t结构的内部,由于考虑了线程的可移植性,该结构在不同的系统中实现有所差别,因此为了增强程序的可移植性,应尽量采用标准可函数提供的属性修改参数.

修改线程所使用的函数都是成对出现的,带有"get"前缀的函数都是获取某属性的当前值,而带有"set"前缀的函数则是设置该属性的值.下面我们列出部分函数.

4.1分离属性

分离属性是用来决定一个线程以什么样的方式来终止自己 .修改分离属性的函数的函数原型如下:

[plain]  view plain copy print ?

1. #include <pthread.h>  
2. int pthread_attr_getdetachstate ( pthread_attr_t *attr, int *detachstate );  
3. int pthread_attr_setdetachstate ( pthread_attr_t *attr, int detachstate );  

返回值:函数成功返回0.任何其他值表示错误.参数detachstate的值为:PTHREAD_CREATE_DETACHED,PTHREAD_CREATE_JOINABLE.

4.2绑定属性

绑定属性就是指一个用户线程固定地分配给一个内核线程,因为CPU时间片的调度是面向内核线程(也就是轻量级进程)的,因此具有绑定属性的线程可以保证在需要的时候总有一个内核线程与之对应.而与之对应的非绑定属性就是指用户线程和内核线程的关系不是始终固定的,而是由系统来控制分配的.修改绑定属性的函数的函数原型如下:

[plain]  view plain copy print ?

1. #include <pthread.h>  
2. int pthread_attr_getscope( pthread_attr_t *tattr, int *scope );  
3. int pthread_attr_setscope( pthread_attr_t *tattr, int scope );  

返回值:函数成功返回0.任何其他值表示错误.PTHREAD_SCOPE_SYSTEM指定将来创建的线程是绑定的,PTHREAD_SCOPE_PROCESS指定将来创建的线程是非绑定的.在一个进程中可以有这两种类型的线程.

4.3堆栈属性

修改堆栈属性的函数的函数原型如下:

[plain]  view plain copy print ?

1. #include <pthread.h>  
2. int pthread_attr_getstacksize( pthread_attr_t *tattr, size_t *size );  
3. int pthread_attr_setstacksize( pthread_attr_t *tattr, int size );  

返回值:函数成功返回0.任何其他值表示错误.参数size表示线程所需堆栈的大小.如果size的值为0,则使用默认大小.在大多数情况下,默认值是最合适的.堆栈的大小不能小于系统定义的最小堆栈容量.

4.4调度策略属性

修改调度策略属性的函数的函数原型如下:

[plain]  view plain copy print ?

1. #include <pthread.h>  
2. int pthread_attr_getschedpolicy( pthread_attr_t *tattr, int *policy );  
3. int pthread_attr_setschedpolicy( pthread_attr_t *tattr, int policy );  

返回值:函数成功返回0.任何其他值表示错误.参数policy的取值有SCHED_FIFO,SCHED_RR,SCHED_OTHER.

4.5发度属性

修改并发度属性的函数的函数原型如下:

[plain]  view plain copy print ?

1. #include <pthread.h>  
2. int pthread_getconcurrency( void );  
3. int pthread_setconcurrency( int new_level );  

返回值:函数成功返回0.任何其他值表示错误.该函数允许一个应用程序通知线程库它所需的并发级别(即同一时刻可以有多少个非绑定线程处于激活状态下).但只是通知系统它所需要的并发级别,系统将它作为一个提示,而不是命令.如果参数new_level的值为0,并行级别将保持不变,就像该函数从来没有被调用过.

[plain]  view plain copy print ?

1. #include <stdio.h>  
2. #include <stdlib.h>  
3. #include <pthread.h>  
4.   
5. void *thread1()  
6. {  
7.     printf("this is thread1.\n");  
8.     sleep(1);  
9.     printf("thread1 return\n");  
10.   
11. }  
12. /*线程2*/  
13. void *thread2()  
14. {  
15.     printf("this is thread2.\n");  
16.     sleep(2);  
17.     printf("thread2 exiting\n");  
18.     pthread_exit (0);  
19. }  
20.   
21. int main(void)  
22. {  
23.     int err;  
24.     pthread_t tid1,tid2;  
25.     pthread_attr_t attr;  
26.       
27.     pthread_attr_init(&attr);  
28.       
29.     pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM);  
30.       
31.     pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_DETACHED);  
32.       
33.     err = pthread_create (&tid1, &attr, thread1, NULL);  
34.     if (err != 0)  
35.     {  
36.         perror("create thread1 error");  
37.         exit(1);  
38.     }  
39.     err = pthread_create (&tid2, NULL, thread2, NULL);  
40.     if (err != 0)  
41.     {  
42.         perror("create thread2 error");  
43.         exit(1);  
44.     }  
45.       
46.     err = pthread_join(tid1, NULL);  
47.     if (err != 0)  
48.     {  
49.         printf("can`t join thread1\n ");  
50.     }  
51.     err = pthread_join(tid2, NULL);  
52.     if (err != 0)  
53.     {  
54.         perror("join thread2 error");  
55.         exit(1);  
56.     }  
57.     pthread_attr_destroy(&attr);  
58.     exit(0);  
59. }  

4.5线程的扩展属性

有两个线程属性没有包含在pthread_attr_t结构中,它们是可取消状态和可取消类型.这两个属性影响着线程在响应pthread_cancel()函数调用时所呈现的行为.
可取消状态属性有两个取值:PTHREAD_CANCEL_ENABLE和PTHREAD_CANCEL_DISABLE.线程启动时默认的可取消状态是 PTHREAD_CANCEL_ENABLE ,当状态设为 PTHREAD_CANCEL_DISABLE 时,对pthread_cancel函数的调用不会杀死线程.线程可以通过调用pthread_setcancelstate()函数修改它的可取消状态,该函数的原型为:

[plain]  view plain copy print ?

1. #include <pthread.h>  
2. int pthread_setcancelstate (int state, int *oldstate);  

此函数把当前的可取消状态置为变量state,把原来的可取消状态存放在oldstate只想的内存单元中,若执行成功则返回0,否则返回错误编码.
此外,还可以修改线程取消动作的执行时机,函数pthread_setcanceltype修改线程的取消类型,有PTHREAD_CANCEL_DEFERRED和PTHREAD_CANCEL_ASYNCHRONOUS两个取值,分别表示线程收到取消信号后继续运行至下一个取消点和立即执行取消动作.该函数的原型为:

[plain]  view plain copy print ?

1. #include <pthread.h>  
2. int  pthread_setcanceltype (int type, int *oldtype);  

参数type的取值可以是PTHREAD_CANCEL_DEFERRED或PTHREAD_CANCEL_ASYNCHRONOUS,原来的值保存在oldstype中.
注意:可取消点是线程检查是否被取消并按照请求进行动作的一个位置.
线程还可以调用pthread_testcancel函数自己添加取消点,该函数的原型为:

[plain]  view plain copy print ?

1. #include <pthread.h>  
2. int  pthread_testcancel (void);  

该函数检查本线程是否处于"待取消"状态(已经收到pthread_cancel的信号,但还没有到达取消点),若可取消状态没有被取消,则线程执行取消动作,否则返回.
下面我们来看一个例子.

[plain]  view plain copy print ?

1. #include <stdio.h>  
2. #include <unistd.h>  
3. #include <stdlib.h>  
4. #include <pthread.h>  
5.   
6. void *thread1(void *arg) {  
7.     int i, err, j;  
8.     err = pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);  
9.     if (err != 0) {  
10.         perror("Thread1 pthread_setcancelstate failed");  
11.         exit(EXIT_FAILURE);  
12.     }  
13.     err = pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, NULL);  
14.     if (err != 0) {  
15.         perror("Thread1 pthread_setcanceltype failed");  
16.         exit(EXIT_FAILURE);  
17.     }  
18.     printf("thread1 is running\n");  
19.     for(i = 0; i < 5; i++) {  
20.         printf("Thread1 is still running (%d)...\n", i);  
21.         sleep(1);  
22.     }  
23.     pthread_exit((void *)2);  
24. }  
25.   
26. void *thread2(void *arg) {  
27.     int i, err, j;  
28.     err = pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);  
29.     if (err != 0) {  
30.         perror("Thread2 pthread_setcancelstate failed");  
31.         exit(EXIT_FAILURE);  
32.     }  
33.     err = pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, NULL);  
34.     if (err != 0) {  
35.         perror("Thread2 pthread_setcanceltype failed");  
36.         exit(EXIT_FAILURE);  
37.     }  
38.     printf("thread2 is running\n");  
39.     for(i = 0; i < 5; i++) {  
40.         printf("Thread2 is still running (%d)...\n", i);  
41.         sleep(1);  
42.     }  
43.     pthread_exit((void *)2);  
44. }  
45.   
46. int main() {  
47.     int err;  
48.     pthread_t tid1,tid2;  
49.     void *thread_result;  
50.   
51.     err = pthread_create(&tid1, NULL, thread1, NULL);  
52.     if (err != 0) {  
53.         perror("Thread1 creation failed");  
54.         exit(EXIT_FAILURE);  
55.     }  
56.     err = pthread_create(&tid2, NULL, thread2, NULL);  
57.     if (err != 0) {  
58.         perror("Thread2 creation failed");  
59.         exit(EXIT_FAILURE);  
60.     }  
61.     sleep(2);  
62.       
63.     printf("Cancelling thread1 ...\n");  
64.     err = pthread_cancel(tid1);  
65.     if (err != 0) {  
66.         perror("Thread1 cancelation failed");  
67.         exit(EXIT_FAILURE);  
68.     }  
69.       
70.     printf("Cancelling thread2 ...\n");  
71.     err = pthread_cancel(tid2);  
72.     if (err != 0) {  
73.         perror("Thread2 cancelation failed");  
74.         exit(EXIT_FAILURE);  
75.     }  
76.   
77.   
78.     printf("Waiting for thread1 to finish...\n");  
79.     err = pthread_join(tid1, &thread_result);  
80.     if (err != 0) {  
81.         perror("Thread1 join failed");  
82.         exit(EXIT_FAILURE);  
83.     }  
84.     printf("The exit code of thread1 :%d\n",(int)thread_result);  
85.   
86.     printf("Waiting for thread2 to finish...\n");  
87.     err = pthread_join(tid2, &thread_result);  
88.     if (err != 0) {  
89.         perror("Thread2 join failed");  
90.         exit(EXIT_FAILURE);  
91.     }  
92.     printf("The exit code of thread2 :%d\n",(int)thread_result);  
93.   
94.     exit(EXIT_SUCCESS);  
95. }  

线程1和线程2创建后即交替运行,由于线程1为可取消状态,当它接收到pthread_cancel的请求时便立即退出了(返回值为-1),而线程2为不可取消状态,因而一直运行到pthread_exit才退出(返回值为2).在上面的例子中,线程1的取消点为sleep函数,下表是常见的取消点.

当接到取消请求后,线程一旦执行到这些函数出现的位置就会退出.除此之外就需要通过pthread_testcancel函数人为的指定取消点.