Linux线程

风雨同行  金牌会员 | 2024-10-14 16:14:09 | 显示全部楼层 | 阅读模式
打印 上一主题 下一主题
楼主

主题 656|帖子 656|积分 1968

线程

从进程到线程

进程是正在执行的步伐，并且是系统资源分配的根本单位。当用户需要在一台盘算机上去完成多个独立的工作任务时，可以使用多进程的方式，为每个独立的工作任务分配一个进程。多进程的管理则由操作系统负责——操作系统调理进程，公道地在多个进程之间分配资源，包括CPU资源、内存、文件等等。除此以外，即便是一个单独的应用，采用多进程的筹划也可以提升其吞吐量，改善其相应时间。假如在处置惩罚任务的过程中，其中一个进程由于死循环或者等候IO之类的原因无法完成任务时，操作系统可以调理另一个进程来完成任务或者相应用户的哀求。比如在文本处置惩罚步伐当中，可以并发地处置惩罚用户输入和保存已完成文件的任务。随着进程进入大规模使用，步伐员在分析性能的时候发现盘算机花费了大量的时间在切换差别的进程上面。当一个进程在执行过程中，CPU的寄存器当中需要保存一些必要的信息，比如堆栈、代码段等，这些状态称作上下文。上下文切换这里涉及到大量的寄存器和内存之间的保存和载入工作。除此以外，Linux操作系统还支持虚拟内存，所以每个用户进程都拥有自己独立的所在空间，这在实现上就要求每个进程有自己独立的页目录表。所以，具体到Linux操作系统，进程切换包括两步：起首是切换页目录表，以支持一个新的所在空间；然后是进入内核态，将硬件上下文，即CPU寄存器的内容以及内核态栈切换到新的进程。
为了缩小创建和切换进程的开销，线程的概念便诞生了。线程又被称为轻量级进程(Light WeightProcess, LWP)，我们将一个进程分解成多个线程，每个线程是独立的运行中步伐实体，线程之间并发运行，如许线程就取代进程成为CPU时间片的分配和调理的最小单位，在Linux操作系统当中，每个线程都拥有自己独立的 task_struct 结构体，固然，在属于同一个进程多个线程中， task_struct 中大量的字段是雷同的或者是共享的。
注意到在Linux操作系统中，线程并没有脱离进程而存在。而盘算机的内存、文件、IO设备等资源依然还是按进程为单位进行分配，属于同一个进程的多个线程会共享进程所在空间，每个线程在执行过程会在所在空间中有自己独立的栈，而堆、数据段、代码段、文件描述符和信号屏蔽字等资源则是共享的。
   同一个进程的多个线程各自拥有自己的栈，这些栈虽然是独立的，但是都位于同一个所在空间中，所以一个线程可以通过所在去访问另一个线程的栈区。
  由于属于同一个进程的多个线程是共享所在空间的，所以线程切换的时候不需要切换页目录表，而且上下文的内容中需要切换的部分也很少，只需要切换栈和PC指针以及其他少量控制信息即可，数据段、代码段等信息可以保持不变。因此，切换线程的花费要小于切换进程的。
   在Linux文件系统中，路径 /proc 挂载了一个伪文件系统，通过这个伪文件系统用户可以采用访问平凡文件的方式（使用read系统调用等），来访问操作系统内核的数据结构。其中，在 /proc/[num] 目录中，就包罗了pid为num的进程的大量的内核数据。而在 /proc/[num]/task 就包罗本进程中全部线程的内核数据。我们之前的编写进程都可以看成是单线程进程。
  用户级线程和内核级线程

根据内查对线程的感知情况，线程可以分为用户级线程和内核级线程。操作系统内核无法调理用户级线程，所以通常会存在一个管理线程（称为运行时），管理线程负责在一个用户线程陷入阻塞的切换到另一个线程。如果线程无法陷入阻塞，则用户需要在代码当中主动调用 yield 以主动让出，否则一个运行中的线程将永久地占用 CPU。用户级线程在 CPU 密集型的任务中毫无作用，而且也无法充分多核架构的上风，所以几乎全部的操作系统都支持内核级线程。
由于用户级线程在处置惩罚IO密集型任务的时候有着肯定的上风，所以现在在一些服务端框架中，混合性线程也引入使用了——在这种情况下，会把用户级线程称为有栈协程。应用步伐会根据硬件中 CPU 的核心数创建若干个内核级线程，每一个内核级线程会对应多个有栈协程。如许在触发IO操作时，不再需要陷入内核态，直接在用户态切换线程即可。
现在使用最广泛的线程库名为 NPTL (Native POSIX Threads Library)，在 Linux 内核2.6版本之后，它取代了传统的 LinuxThreads 线程库。NPTL支持了POSIX的线程尺度库，在早期，NPTL 只支持用户级线程，随着内核版本的迭代，现在每一个用户级线程都对应一个内核态线程，如许 NPTL 线程本质就成为了内核级线程，可被操作系统调理。
线程的创建和终止

使用线程的思路实在和使用进程的思路类似，用户需要去关心线程的创建、退出和资源回收等活动，初学者可以参考之前学习进程的方式对比学习线程对应的库函数。下面是常用的线程库函数和之前的进程的对应关系。
线程函数功能类似的进程函数pthread_create创建一个线程forkpthread_exit线程退出exitpthread_join等候线程结束并回收资源waitpthread_self获取线程idgetpid 在使用线程相干的函数之后，在链接时需要加上 -lpthread 选项以显式链接线程库。
线程函数的错误处置惩罚

之前的POSIX系统调用和库函数在调用堕落的时候，通常会把全局变量 errno 设置为一个特别的数值以指示报错的类型，如许就可以调用 perror 以表现符合人阅读需求的报错信息。但是在多线程编程之中，全局变量是各个线程的共享资源，很轻易被并发地读写，所以pthread系列的函数不会通过修改 errno 来指示报错的类型，它会根据差别的错误类型返回差别的返回值，使用 strerror 函数可以根据返回值表现报错字符串。
  1. char *strerror(int errnum);
  2. #define THREAD_ERROR_CHECK(ret,msg) {if(ret!=0){\
  3. fprintf(stderr,"%s:%s\n",msg,strerror(ret));}}
复制代码
创建线程

线程创建使用的函数是 pthread_create，这个函数的函数原型如下：
  1. #include <pthread.h>
  2. int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg);
复制代码
在一个进程当中的差别线程都拥有自己独立唯一的线程id（thread id），NPTL 使用 pthread_t 类型来保存线程 id，在差别的操作系统中，pthread_t 底层实现差别，具体到 Linux 是一个无符号整型数，使用函数 pthread_self 可以获取本线程的 id。
  1. //获取本线程的tid
  2. int main()
  3. {
  4.     printf("pid = %d,tid = %lu\n",getpid(),pthread_self());
  5.     return 0;
  6. }
复制代码
调用 pthread_create 会创建出一个新的线程。创建者需要分配空间去存储一个线程 id（比如在栈帧上面），并且将其所在传入 pthread_create 函数。 attr 参数可以用来指定创建出来的线程的属性，一般可以控制其调理相干的信息，如果传入的是 NULL，那么表示采用默认的线程属性。 start_routine 是一个函数指针类型的参数，其返回值和参数都是 void *， start_routine 的职位类似于主线程的 main 函数，它作为线程执行的入口函数。 arg 是通报给 start_routine 的参数。
  1. //下面是一个不传递参数的版本
  2. void * threadFunc(void *arg){
  3.     printf("I am child thread, tid = %lu\n",
  4.     pthread_self());
  5.     return NULL;
  6. }
  8. int main(){
  9.     pthread_t tid;
  10.     int ret = pthread_create(&tid,NULL,threadFunc,NULL);
  11.     THREAD_ERROR_CHECK(ret,"pthread_create");
  12.     printf("I am main thread, tid = %lu\n", pthread_self());
  13.     sleep(1);
  14.     //usleep(20);
  15.     //_exit(0);
  16.     return 0;
  17. }
复制代码
在上面的例子当中，如果将 sleep(1) 改成 usleep(20) ，线程并发执行的特点会导致一些看上去非常奇怪的结果：在某次执行的时候，尺度输出上有肯定的几率表现两条雷同的语句。产生这种问题的原因是如许的，stdout 缓冲区在多个线程之间是共享，当执行 printf 时，会起首将 stdout 的内容拷贝到内核态的文件对象中，再清空缓冲区，当主线程终止导致全部线程终止时，可能子线程已经将数据拷贝到了内核态（此时第一份语句已经打印了），但是 stdout 的内容并未清空，此时进程终止，会把全部缓冲区清空，清空缓冲区的活动会将留存在缓冲区的内容直接清空并输出到尺度输出中，此时就会出现内容的重复打印了。
线程和数据共享

多个线程是共享一片所在空间的，所以各个线程可以并发地访问的同一个数据段、堆空间和其他位置。
下面是一个共享数据段的例子：
  1. //多线程共享数据段
  2. #include <func.h>
  3. #include "test.h"
  4. int global= 100;
  5. void * threadFunc(void *arg){
  6.     printf("I am child thread, tid = %lu\n",
  7.     pthread_self());
  8.     printf("child thread, global = %d\n", global);
  9.     return NULL;
  10. }
  11. int main(){
  12.     pthread_t tid;
  13.     int ret = pthread_create(&tid,NULL,threadFunc,NULL);
  14.     THREAD_ERROR_CHECK(ret,"pthread_create");
  15.     printf("I am main thread, tid = %lu\n",
  16.     pthread_self());
  17.     global = 200;
  18.     printf("main thread, global = %d\n", global);
  19.     sleep(1);
  20.     return 0;
  21. }
复制代码
堆空间自然也是可以共享的，我们通过会将堆空间的首所在作为参数在创建线程的时候进行通报，无论是子线程还是主线程访问的区域都是同一片空间。
  1. //多线程共享堆空间
  2. void * threadFunc(void *arg){
  3.     char *pHeap = (char *)arg;
  4.     printf("I am child thread, tid = %lu\n",
  5.     pthread_self());
  6.     strcpy(pHeap,"world");
  7.     printf("child thread, %s\n",pHeap);
  8.     return NULL;
  9. }
  11. int main(){
  12.     pthread_t tid;
  13.     char *pHeap = (char *)malloc(20);
  14.     strcpy(pHeap,"hello");
  15.     int ret = pthread_create(&tid,NULL,threadFunc,(void *)pHeap);
  16.     THREAD_ERROR_CHECK(ret,"pthread_create");
  17.     printf("I am main thread, tid = %lu\n",
  18.     pthread_self());
  19.     sleep(1);
  20.     printf("parent thread, %s\n",pHeap);
  21.     free(pHeap);
  22.     return 0;
  23. }
复制代码
虽然说 arg 是一个 void* 类型的参数，这暗示着用户可以使用该参数来通报一个数据的所在，但是有些情况下我们只需要通报一个整型数据，在这种情况，用户可以直接把 void* 类型的参数当成是一个8字节的平凡数据(比如long)进行通报。
  1. void * threadFunc(void *arg){
  2.     printf("I am child thread, tid = %lu\n",
  3.     pthread_self());
  4.     //把参数当成是普通的8字节整型
  5.     printf("child, val = %ld\n",(long)arg);
  6.     return NULL;
  7. }
  9. int main(){
  10.     pthread_t tid;
  11.     long val = 1001;
  12.     int ret = pthread_create(&tid,NULL,threadFunc,(void *)val);
  13.     THREAD_ERROR_CHECK(ret,"pthread_create");
  14.     val = 1002;
  15.     ret = pthread_create(&tid,NULL,threadFunc,(void *)val);
  16.     THREAD_ERROR_CHECK(ret,"pthread_create");
  17.     printf("I am main thread, tid = %lu\n",
  18.     pthread_self());
  19.     sleep(1);
  20.     return 0;
  21. }
复制代码
需要注意的是，虽然各个线程执行的过程中拥有自己独立的栈区，但是这些全部的栈区都是在同一个所在空间当中，所以一个线程完全可以访问到另一个线程栈帧内部的数据。
  1. void * threadFunc(void *arg){
  2.     printf("I am child thread, tid = %lu\n",
  3.     pthread_self());
  4.     int * pval = (int *)arg;
  5.     *pval = 1002;
  6.     printf("child, val = %d\n",*pval);
  7.     return NULL;
  8. }
  10. int main()
  11. {
  12.     pthread_t tid;
  13.     int val = 1001;
  14.     int ret = pthread_create(&tid,NULL,threadFunc,(void *)&val);
  15.     THREAD_ERROR_CHECK(ret,"pthread_create");
  16.     printf("I am main thread, tid = %lu\n",
  17.     pthread_self());
  18.     sleep(1);
  19.     //虽然栈帧是私有的，但是其他线程依然有权限读写
  20.     printf("main, val = %d\n",val);
  21.     return 0;
  22. }
复制代码
如果将主线程栈帧数据的所在作为参数通报给各个子线程，就肯定要注意并发访问的情况，有可能另一个线程的执行会修改掉原本想要通报数据的内容。
  1. //各个子线程会打印相同的结果
  2. void * threadFunc(void *arg){
  3.     printf("I am child thread, tid = %lu\n",
  4.     pthread_self());
  5.     int * pval = (int *)arg;
  6.     printf("child, val = %d\n",*pval);
  7.     return NULL;
  8. }
  10. int main()
  11. {
  12.     pthread_t tid;
  13.     int val = 1001;
  14.     int ret = pthread_create(&tid,NULL,threadFunc,(void *)&val);
  15.     THREAD_ERROR_CHECK(ret,"pthread_create");
  16.     val = 1002;
  17.     ret = pthread_create(&tid,NULL,threadFunc,(void *)&val);
  18.     THREAD_ERROR_CHECK(ret,"pthread_create");
  19.     printf("I am main thread, tid = %lu\n",
  20.     pthread_self());
  21.     sleep(1);
  22.     return 0;
  23. }
复制代码
线程主动退出

使用 pthread_exit 函数可以主动退出线程，无论这个函数是否是在 start_routine 中被调用，其活动类似于进程退出的 exit 。 pthread_exit 的参数是一个 void * 类型值，它描述了线程的退出状态。在 start_routine 中使用return语句可以实现类似的主动退出效果，但是其被动退出的活动有一些问题，所以使用较少。线程的退出状态可以由另一个线程使用 pthread_join 捕获，但是和进程不一样的是，另一个线程的选择是任意的，不需要是线程创建者。
  1. void pthread_exit(void *retval);
复制代码
下面是线程主动退出的例子：
  1. void * threadFunc(void *arg){
  2.     printf("I am child thread, tid = %lu\n",
  3.     pthread_self());
  4.     //pthread_exit(NULL);和在线程入口函数return(NULL)等价
  5.     printf("Can you see me?\n");
  6. }
  8. int main()
  9. {
  10.     pthread_t tid;
  11.     int ret = pthread_create(&tid,NULL,threadFunc,NULL);
  12.     THREAD_ERROR_CHECK(ret,"pthread_create");
  13.     printf("I am main thread, tid = %lu\n",
  14.     pthread_self());
  15.     sleep(1);
  16.     return 0;
  17. }
复制代码
获取线程退出状态

调用 pthread_join 可以使本线程处于等候状态，直到指定的 thread 终止，就结束等候，并且捕获到的线程终止状态存入 retval 指针所指向的内存空间中。由于线程的终止状态是一个 void * 类型的数据，所以 pthread_join 的调用者往往需要先申请8个字节大小的内存空间，然后将其首所在传入，在 pthread_join 的执行之后，这里面的数据会被修改。有些时候，内容可能是一片数据的首所在，另有些情况下内容就是简单的一个8字节的整型。
  1. int pthread_join(pthread_t thread, void **retval);
复制代码
下面是例子，分别用整型数字或者20字节的堆空间来描述退出状态。
  1. void * threadFunc(void *arg){
  2.     printf("I am child thread, tid = %lu\n",
  3.     pthread_self());
  4.     //pthread_exit(NULL);//相当于返回成一个8字节的0
  5.     //pthread_exit((void *)1);
  6.     char *tret = (char *)malloc(20);
  7.     strcpy(tret,"hello");
  8.     return (void *)tret;
  9. }
  11. int main()
  12. {
  13.     pthread_t tid;
  14.     int ret = pthread_create(&tid,NULL,threadFunc,NULL);
  15.     THREAD_ERROR_CHECK(ret,"pthread_create");
  16.     printf("I am main thread, tid = %lu\n",
  17.     pthread_self());
  18.     void *tret;//在调用函数中申请void*变量
  19.     ret = pthread_join(tid,&tret);//传入void*变量的地址
  20.     THREAD_ERROR_CHECK(ret,"pthread_join");
  21.     //printf("tret = %ld\n", (long) tret);
  22.     printf("tret = %s\n", (char *)tret);
  23.     return 0;
  24. }
复制代码
在使用 pthread_join 要特别注意参数的类型， thread 参数是不需要取所在的，如果参数错误，有些情况下可能会陷入无限等候，另有些情况会立刻终止，触发报错。
  1. void * threadFunc(void *arg){
  2.     printf("I am child thread, tid = %lu\n",
  3.     pthread_self());
  4.     pthread_exit(NULL);
  5. }
  7. int main()
  8. {
  9.     pthread_t tid;
  10.     int ret = pthread_create(&tid,NULL,threadFunc,NULL);
  11.     THREAD_ERROR_CHECK(ret,"pthread_create");
  12.     printf("I am main thread, tid = %lu\n",
  13.     pthread_self());
  14.     ret = pthread_join(0,NULL);//如果第一个参数填入&tid，就会陷入无限等待
  15.     THREAD_ERROR_CHECK(ret,"pthread_join");
  16.     return 0;
  17. }
复制代码
线程的取消和资源清理

线程的取消

线程除了可以主动退出以外，还可以被另一个线程终止。不外起首值得注意的是，我们不能轻易地在多线程步伐使用信号，由于多线程是共享代码段的，从而信号处置惩罚的回调函数也是共享的，当产生一个信号到进程时，进程中用于递送信号的线程是随机的，很有可能会出现主线程因递送信号而终止从而导致全部线程异常退出的情况。
因此，要实现线程的有序退出，线程内部需要实现一种不依靠于信号的机制，这就是线程的取消 pthread_cancel 的工作职责。当一个线程调用 pthread_cancel 去取消另一个线程的时候，另一个线程会将本线程的取消标志位设置为真，当这个线程执行一些函数之时，线程就会退出。这些会导致已取消未终止的线程终止的函数称为取消点。
  1. int pthread_cancel(pthread_t thread);
复制代码
查看资助手册( pthreads(7) )可以确定大部分取消点函数。通常来说，会引起阻塞或者是访问文件的操作就是取消点。值得注意的是，加锁 pthread_mutex_lock 和解锁函数 pthread_mutex_unlock 以及其他和锁相干的函数都不是取消点。
  1. $man 7 pthreads
  2. 部分取消点：
  3.     accept()
  4.     close()
  5.     connect()
  6.     open()
  7.     pthread_cond_timedwait()
  8.     pthread_cond_wait()
  9.     pthread_join()
  10.     pthread_testcancel()
  11.     read()
复制代码
下面是线程取消成功的一个例子，由于子线程在受到取消信号以后，会继续运行到 printf 为止。
  1. void * threadFunc(void *arg){
  2.     printf("I am child thread, tid = %lu\n",
  3.     pthread_self());
  4.     return (void *)0;
  5. }
  7. int main()
  8. {
  9.     pthread_t tid;
  10.     int ret = pthread_create(&tid,NULL,threadFunc,NULL);
  11.     THREAD_ERROR_CHECK(ret,"pthread_create");
  12.     printf("I am main thread, tid = %lu\n",
  13.     pthread_self());
  14.     void * pret;
  15.     ret = pthread_cancel(tid);
  16.     THREAD_ERROR_CHECK(ret,"pthread_cancel");
  17.     ret = pthread_join(tid,&pret);
  18.     THREAD_ERROR_CHECK(ret,"pthread_join");
  19.     printf("thread return = %ld\n", (long) pret);
  20.     return 0;
  21. }
  22. //可以发现pthread_cancel执行成功，因为获取的返回值是-1而不是正常退出的0
复制代码
如果被取消的线程没有运行到取消点，那么这个线程将不会终止：
  1. void * threadFunc(void *arg){
  2.     while(1);
  3.     return (void *)0;
  4. }
  6. int main()
  7. {
  8.     pthread_t tid;
  9.     int ret = pthread_create(&tid,NULL,threadFunc,NULL);
  10.     THREAD_ERROR_CHECK(ret,"pthread_create");
  11.     printf("I am main thread, tid = %lu\n",
  12.     pthread_self());
  13.     void * pret;
  14.     ret = pthread_cancel(tid);
  15.     THREAD_ERROR_CHECK(ret,"pthread_cancel");
  16.     ret = pthread_join(tid,&pret);
  17.     THREAD_ERROR_CHECK(ret,"pthread_join");
  18.     printf("thread return = %ld\n", (long) pret);
  19.     return 0;
  20. }
复制代码
使用命令 ps -elLf 可以查看线程的状态。
  1. $ps -elLf
复制代码
下面是使用 pthread_testcancel 的例子
  1. void *threadFunc(void *arg){
  2.     while(1){
  3.             pthread_testcancel();
  4.     }
  5. }
  7. int main()
  8. {
  9.     pthread_t tid;
  10.     pthread_create(&tid,NULL,threadFunc,NULL);
  11.     sleep(1);
  12.     printf("sleep over!\n");
  13.     pthread_cancel(tid);
  14.     void *ret;
  15.     pthread_join(tid,&ret);
  16.     printf("You die, ret = %ld\n", (long ) ret);
  17.     return 0;
  18. }
复制代码
综上，线程取消和之前的信号筹划有着显著的区别，被取消的线程并不是立刻退出。除此之外，线程被取消的时候还可以执行资源清理的工作。在结合资源清理活动之后，线程取消的流程大抵如下：


  • 起首主动方调用取消函数给被取消方发送取消信号。
  • 被取消方设置取消标志为真，继续运行直到一个取消点。
  • 执行线程终止清理函数，以释放占用的资源。
  • 烧毁thread local数据。
  • 终止本线程。
线程资源清理

在引入线程取消之后，步伐员在管理资源回收的难度上会急剧提升。为了简化资源清理活动，线程库引入了 pthread_cleanup_push 和 pthread_cleanup_pop 函数来管理线程主动或者被动终止时所申请资源（比如文件、堆空间、锁等等）。
  1. void pthread_cleanup_push(void (*routine)(void *), void *arg);
  2. void pthread_cleanup_pop(int execute);
复制代码
pthread_cleanup_push 负责将清理函数压入一个栈中，这个栈会在下列情况下弹出：


  • 线程由于取消而终止时，全部清理函数按照后进先出的次序从栈中弹出并执行。
  • 线程调用 pthread_exit 而主动终止时，全部清理函数按照后进先出的次序从栈中弹出并执行。
  • 线程调用 pthread_clean_pop 并且 execute 参数非0时，弹出栈顶的清理函数并执行。
  • 线程调用 pthread_clean_pop 并且 execute 参数为0时，弹出栈顶的清理函数不执行。
值得特别注意的是：当线程在 start_routine 中执行return语句而终止的时候，清理函数不会弹栈！
  1. void cleanup(void *p){
  2.     free(p);
  3.     printf("I am cleanup\n");
  4. }
  6. void * threadFunc(void *arg){
  7.     void *p = malloc(100000);
  8.     pthread_cleanup_push(cleanup,p);//一定要在cancel点之前push
  9.     printf("I am child thread, tid = %lu\n",
  10.     pthread_self());
  11.     //pthread_exit((void *)0);//在pop之前exit，cleanup弹栈并被调用
  12.     pthread_cleanup_pop(1);//在exit之后pop cleanup弹栈，如果参数为1被调用
  13.     pthread_exit((void *)0);
  14. }
  16. int main()
  17. {
  18.     pthread_t tid;
  19.     int ret = pthread_create(&tid,NULL,threadFunc,NULL);
  20.     THREAD_ERROR_CHECK(ret,"pthread_create");
  21.     printf("I am main thread, tid = %lu\n",
  22.     pthread_self());
  23.     void * pret;
  24.     //ret = pthread_cancel(tid);
  25.     //THREAD_ERROR_CHECK(ret,"pthread_cancel");
  26.     ret = pthread_join(tid,&pret);
  27.     THREAD_ERROR_CHECK(ret,"pthread_join");
  28.     printf("thread return = %ld\n", (long) pret);
  29.     return 0;
  30. }
复制代码
POSIX要求 pthread_cleanup_push 和 pthread_cleanup_pop 必须成对出现在同一个作用域当中，主要是为了束缚步伐员在清理函数当中活动。下面是在 /urs/include/pthread.h 文件当中，线程清理函数的定义：
  1. #define pthread_cleanup_push(routine, arg) \
  2. do { \
  3. __pthread_cleanup_class __clframe (routine, arg)
  4. /* Remove a cleanup handler installed by the matching pthread_cleanup_push.
  5. If EXECUTE is non-zero, the handler function is called. */
  6. #define pthread_cleanup_pop(execute) \
  7. __clframe.__setdoit (execute); \
  8. } while (0)
复制代码
可以发现push和pop的宏定义不是语义完全的，它们必须在同一作用域中成对出现才能使花括号成功匹配。
下面是压入多个清理函数的例子：
  1. void cleanup(void *p){
  2.         printf("clean up, %s\n", (char *)p);
  3. }
  5. void * threadFunc(void *arg){
  6.     pthread_cleanup_push(cleanup,(void *)"first");
  7.     pthread_cleanup_push(cleanup,(void *)"second");
  8.     //pthread_exit((void *)0);
  9.     return (void *)0;
  10.     pthread_cleanup_pop(1);
  11.     pthread_cleanup_pop(1);
  12. }
  14. int main()
  15. {
  16.     pthread_t tid;
  17.     int ret;
  18.     ret = pthread_create(&tid,NULL,threadFunc,NULL);
  19.     THREAD_ERROR_CHECK(ret,"pthread_create");
  20.     ret = pthread_join(tid,NULL);
  21.     THREAD_ERROR_CHECK(ret,"pthread_join");
  22.     return 0;
  23. }
复制代码
线程的同步和互斥

由于多线程之间不存在隔离，共享同一个所在在进步运行效率的同时也给用户带来了巨大的困扰。在并发执行的情况下，大量的共享资源成为竞争条件，导致步伐执行的结果往往和预期的内容大相径庭，如果一个步伐的结果是不精确的，那么再高的效率也毫偶尔义。在基于之进步程对并发的研究之上，线程库也提供了专门用于精确地访问共享资源的机制。
互斥锁的根本使用

在多线程编程中，用来控制共享资源的最简单有效也是最广泛使用的机制就是 mutex(MUTual EXclusion) ，即互斥锁。锁的数据类型是 pthread_mutex_t，其本质是一个全局的标志位，线程可以对作原子地测试并修改，即所谓的加锁。当一个线程持有锁的时候，其余线程再尝试加锁时（包括自己再次加锁），会使自己陷入阻塞状态，直到锁被持有线程解锁才能规复运行。所以锁在某个时刻永久不能被两个线程同时持有。
创建锁有两种形式：直接用 PHTREAD_MUTEX_INITIALIZER 初始化一个 pthread_mutex_t 类型的变量，即静态初始化锁；而使用 pthread_mutex_init 函数可以动态创建一个锁。动态创建锁的方式更加常见。
使用 pthread_mutex_destory 可以烧毁一个锁。
  1. pthread_mutex_t fastmutex = PTHREAD_MUTEX_INITIALIZER;
  2. int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *mutexattr);
  3. int pthread_mutex_destroy(pthread_mutex_t *mutex);
  4. int pthread_mutex_lock(pthread_mutex_t *mutex);
  5. int pthread_mutex_unlock(pthread_mutex_t *mutex);
  6. int pthread_mutex_trylock(pthread_mutex_t *mutex);
复制代码
下面是最根本的使用锁的例子，编程规范要求：谁加锁，谁解锁。锁的使用纷繁复杂，如果不按照规范行事，一方面会很轻易出现错误，并且堕落之后很难排查，另一方面，随意解锁会导致代码的可读性极差，无法后续调整优化。
  1. typedef struct shareRes_s{
  2.         pthread_mutex_t mutex;
  3. } shareRes_t, *pShareRes_t;
  5. void *threadFunc(void *arg){
  6.     pthread_mutex_lock(&((pShareRes_t)arg)->mutex);
  7.     puts("I am child thread");
  8.     pthread_mutex_unlock(&((pShareRes_t)arg)->mutex);
  9. }
  11. int main()
  12. {
  13.     shareRes_t shared;
  14.     pthread_t tid;
  15.     pthread_mutex_init(&shared.mutex,NULL);
  16.     pthread_create(&tid,NULL,threadFunc,&shared);
  17.     sleep(1);
  18.     //pthread_mutex_unlock(&shared.mutex);
  19.     //虽然是可行的，但是不符合规范
  20.     pthread_mutex_lock(&shared.mutex);
  21.     pthread_join(tid,NULL);
  22.     puts("I am main thread");
  23.     return 0;
  24. }
复制代码
使用互斥锁访问共享资源

如果两个线程并发地对共享资源进行读写操作，就有可能出现竞争条件，如果在每次访问共享资源的时候都精确地使用锁（即访问之前加锁，访问之后解锁），那么步伐就会得到精确的运行结果。
  1. typedef struct shareRes_s{
  2.     int val;
  3.     pthread_mutex_t mutex;
  4. } shareRes_t,*pshareRes_t;
  6. void *threadFunc(void *arg){
  7.     pshareRes_t pshared = (pshareRes_t)arg;
  8.     for(int i = 0;i < 20000000; ++i){
  9.         pthread_mutex_lock(&pshared->mutex);
  10.         ++pshared->val;
  11.         pthread_mutex_unlock(&pshared->mutex);
  12.     }
  13.     pthread_exit(NULL);
  14. }
  16. int main()
  17. {
  18.     int ret;
  19.     pthread_t tid;
  20.     shareRes_t shareRes;
  21.     shareRes.val = 0;
  22.     ret = pthread_mutex_init(&shareRes.mutex,NULL);
  23.     THREAD_ERROR_CHECK(ret,"pthread_mutex_init");
  24.     struct timeval begTime, endTime;
  25.     gettimeofday(&begTime,NULL);
  26.     ret = pthread_create(&tid,NULL,threadFunc,(void *)&shareRes);
  27.     THREAD_ERROR_CHECK(ret,"pthread_create");
  28.     for(int i = 0;i < 20000000; ++i){
  29.         pthread_mutex_lock(&shareRes.mutex);
  30.         ++shareRes.val;
  31.         pthread_mutex_unlock(&shareRes.mutex);
  32.     }
  33.     ret = pthread_join(tid,NULL);
  34.     THREAD_ERROR_CHECK(ret,"pthread_join");
  35.     gettimeofday(&endTime,NULL);
  36.     long avgtime = ((endTime.tv_sec - begTime.tv_sec )* 1000000 + (endTime.tv_usec - begTime.tv_usec));
  37.     printf("avg lock/unlock time = %ld\n",avgtime);
  38.     printf("val = %d\n", shareRes.val);
  39.     ret = pthread_mutex_destroy(&shareRes.mutex);
  40.     THREAD_ERROR_CHECK(ret,"pthread_mutex_destroy");
  41.     return 0;
  42. }
复制代码
另外就是要注意到，使用线程互斥量的效率要比之前的进程间通讯信号量机制好很多，所以实际工作中几乎都是使用线程互斥锁来实现互斥。
可以使用 pthread_mutex_trylock 函数来非阻塞地加锁，假如已经加锁成功，函数会直接返回。
  1. typedef struct shareRes_s{
  2.         pthread_mutex_t mutex;
  3. } shareRes_t, *pShareRes_t;
  5. void *threadFunc(void *arg){
  6.     //pthread_mutex_lock(&((pShareRes_t)arg)->mutex);
  7.     puts("I am child thread");
  8. }
  9. int main()
  10. {
  11.     shareRes_t shared;
  12.     pthread_t tid;
  13.     int ret;
  14.     pthread_mutex_init(&shared.mutex,NULL);
  15.     pthread_create(&tid,NULL,threadFunc,&shared);
  16.     sleep(1);
  17.     ret = pthread_mutex_trylock(&shared.mutex);
  18.     THREAD_ERROR_CHECK(ret,"pthread_mutex_trylock");
  19.     pthread_mutex_unlock(&shared.mutex);
  20.     pthread_join(tid,NULL);
  21.     puts("I am main thread");
  22.     return 0;
  23. }
复制代码
互斥锁堕落的例子

使用互斥锁的时候肯定要注意访问共享资源的过程是否肯定处于锁的保护下，下面是一个卖火车票的例子，它的运行偶尔候就会出现异常。
  1. typedef struct shareRes_s{
  2.     pthread_mutex_t mutex;
  3.     pthread_cond_t cond;
  4.     int ticketNum;
  5. } shareRes_t, *pshareRes_t;
  7. void *sellTicket1(void *arg){
  8.     sleep(1);
  9.     pshareRes_t pshared = (pshareRes_t)arg;
  10.     while(pshared->ticketNum > 0){
  11.         pthread_mutex_lock(&pshared->mutex);
  12.         printf("Before 1 sells tickets, ticketNum = %d\n", pshared->ticketNum);
  13.         --pshared->ticketNum;
  14.         printf("After 1 sells tickets, ticketNum = %d\n", pshared->ticketNum);
  15.         pthread_mutex_unlock(&pshared->mutex);
  16.         }
  17.         pthread_exit(NULL);
  18. }
  20. void *sellTicket2(void *arg){
  21.     sleep(1);
  22.     pshareRes_t pshared = (pshareRes_t)arg;
  23.     while(pshared->ticketNum > 0){
  24.         pthread_mutex_lock(&pshared->mutex);
  25.         printf("Before 2 sells tickets, ticketNum = %d\n", pshared->ticketNum);
  26.         --pshared->ticketNum;
  27.         printf("After 2 sells tickets, ticketNum = %d\n", pshared->ticketNum);
  28.         pthread_mutex_unlock(&pshared->mutex);
  29.     }
  30.     pthread_exit(NULL);
  31. }
  33. int main()
  34. {
  35.     shareRes_t shared;
  36.     shared.ticketNum = 20;
  37.     int ret;
  38.     ret = pthread_mutex_init(&shared.mutex,NULL);
  39.     THREAD_ERROR_CHECK(ret,"pthread_mutex_init");
  40.     ret = pthread_cond_init(&shared.cond,NULL);
  41.     THREAD_ERROR_CHECK(ret,"pthread_cond_init");
  42.     pthread_t tid1,tid2;
  43.     pthread_create(&tid1,NULL,sellTicket1,(void *)&shared);
  44.     pthread_create(&tid2,NULL,sellTicket2,(void *)&shared);
  45.     pthread_join(tid1,NULL);
  46.     pthread_join(tid2,NULL);
  47.     pthread_cond_destroy(&shared.cond);
  48.     pthread_mutex_destroy(&shared.mutex);
  49.     return 0;
  50. }
复制代码
上面的例子出问题的原因很简单，就是 ticketNum 这个数据并不总是在持有锁的情况下（在while循环入口的位置）被访问，如很多线程交织执行的时候就会出现竞争问题。
  1. typedef struct shareRes_s{
  2.     pthread_mutex_t mutex;
  3.     int ticketNum;
  4. } shareRes_t, *pShareRes_t;
  6. void *threadFunc1(void *arg){
  7.     pShareRes_t p = (pShareRes_t) arg;
  8.     int mySell = 0;
  9.     while(1){
  10.         pthread_mutex_lock(&p->mutex);
  11.         if(p->ticketNum <= 0){
  12.             pthread_mutex_unlock(&p->mutex);
  13.             printf("I am 1, sell = %d\n", mySell);
  14.             break;
  15.             }
  16.         --p->ticketNum;
  17.         ++mySell;
  18.         pthread_mutex_unlock(&p->mutex);
  19.         //sleep(1);
  20.         }
  21.         pthread_exit(NULL);
  22. }
  24. void *threadFunc2(void *arg){
  25.         pShareRes_t p = (pShareRes_t) arg;
  26.         int mySell = 0;
  27.     while(1){
  28.         pthread_mutex_lock(&p->mutex);
  29.         if(p->ticketNum <= 0){
  30.             pthread_mutex_unlock(&p->mutex);
  31.             printf("I am 2, sell = %d\n", mySell);
  32.             break;
  33.             }
  34.         --p->ticketNum;
  35.         ++mySell;
  36.         pthread_mutex_unlock(&p->mutex);
  37.         //sleep(1);
  38.     }
  39.     pthread_exit(NULL);
  40. }
  42. int main()
  43. {
  44.     shareRes_t shared;
  45.     pthread_mutex_init(&shared.mutex,NULL);
  46.     //shared.ticketNum = 2000;
  47.     shared.ticketNum = 20000000;
  48.     pthread_t tid1,tid2;
  49.     pthread_create(&tid1,NULL,threadFunc1,&shared);
  50.     pthread_create(&tid2,NULL,threadFunc2,&shared);
  51.     pthread_join(tid1,NULL);
  52.     pthread_join(tid2,NULL);
  53.     puts("I am main thread");
  54.     return 0;
  55. }
复制代码
死锁

使用互斥锁的时候必须警惕审慎，如果是需要连续多个锁的情况，加锁和解锁之间必须要维持肯定的次序。纵然是只有一把锁，如果使用不当，也会导致死锁。当一个线程持有了锁以后，又试图对同一把锁加锁时，线程会陷入死锁状态。
可以使用 pthread_mutexattr_settype 函数修改锁的属性，检错锁在重复加锁是会报错，递归锁或者称为可重入锁在重复加锁不会死锁时，只是会增长锁的引用计数，解锁时也只是镌汰锁的引用计数。但是在实际工作中，如果一个筹划必须依靠于递归锁，那么这个筹划肯定是有问题的。
  1. typedef struct shareRes_s{
  2.         pthread_mutex_t mutex;
  3. } shareRes_t, *pShareRes_t;
  5. void *threadFunc(void *arg){
  6.     pShareRes_t p = (pShareRes_t)arg;
  7.     pthread_mutex_lock(&p->mutex);
  8.     puts("fifth");
  9.     pthread_mutex_unlock(&p->mutex);
  10. }
  12. int main()
  13. {
  14.     shareRes_t shared;
  15.     int ret;
  16.     pthread_mutexattr_t mutexattr;
  17.     pthread_mutexattr_init(&mutexattr);
  18.     //ret = pthread_mutexattr_settype(&mutexattr,PTHREAD_MUTEX_ERRORCHECK);
  19.     ret = pthread_mutexattr_settype(&mutexattr,PTHREAD_MUTEX_RECURSIVE);
  20.     THREAD_ERROR_CHECK(ret,"pthread_mutexattr_settype");
  21.     pthread_t tid;
  22.     pthread_create(&tid,NULL,threadFunc,(void *)&shared);
  23.     pthread_mutex_init(&shared.mutex,&mutexattr);
  24.     ret = pthread_mutex_lock(&shared.mutex);
  25.     THREAD_ERROR_CHECK(ret,"pthread_mute_lock 1");
  26.     puts("first");
  27.     ret = pthread_mutex_lock(&shared.mutex);
  28.     THREAD_ERROR_CHECK(ret,"pthread_mute_lock 2");
  29.     puts("second");
  30.     pthread_mutex_unlock(&shared.mutex);
  31.     puts("third");
  32.     pthread_mutex_unlock(&shared.mutex);//两次加锁，要有两次解锁
  33.     puts("forth");
  34.     pthread_join(tid,NULL);
  35.     return 0;
  36. }
复制代码
  我们现在所使用的mutex互斥锁是一种就寝锁，不满意条件的线程会陷入就寝状态。还存在另一个锁称作自旋锁，当线程不满意条件时，线程会一直死循环直到条件成立。一般恰当用于条件很快就会被满意的情况。实际上操作系统内核实现互斥锁的底层就用了自旋锁。
  同步和条件变量

理论上来说，使用互斥锁可以解决全部的同步问题，但是生产实践之中往往会出现如许的问题：一个线程能否执行取决于业务的状态，而该状态是多线程共享的，状态的数值会随着步伐的运行不断地变革，线程也经常在可运行和不可运行之间动态切换。假如单纯使用互斥锁来解决问题的话，就会出现大量的重复的“加锁-检查条件不满意-解锁”的活动，如许的话，不满意条件的线程会经常试图占用CPU资源，上下文切换也会非常频繁。
对于如许依靠于共享资源这种条件来控制线程之间的同步的问题，我们盼望采用一种无竞争的方式让多个线程在共享资源处会和——这就是条件变量。当涉及到同步问题时，业务上需要筹划一个状态条件（一般是一个标志位）来表示该线程到底是可运行还是不可运行的，这个状态是多线程共享的，故修改的时候必须加锁访问，这就意味着条件变量肯定要配合锁来使用。条件变量是一种“等候-唤醒”机制：线程运行的时候发现不满意执行的状态可以等候，线程运行的时候如果修改了状态可以唤醒其他线程。
接下来我们来举一个条件变量的例子。
业务场景：假设有两个线程t1和t2并发运行，t1会执行A事件，t2会执行B事件，现在业务要求，无论t1或t2哪个线程先占用CPU，总是需要满意A先B后的同步次序。
解决方案：


  • 在t1和t2线程执行之前，先初始化状态为B不可执行。
  • t1线程执行A事件，执行完成以后先加锁，修改状态为B可执行，并唤醒条件变量，然后解锁（解锁和唤醒这两个操作可以互换次序）；
  • t2线程先加锁，然后检查状态：假如B不可执行，则B阻塞在条件变量上，当t2阻塞在条件变量以后，t2线程会解锁并陷入阻塞状态直到t1线程唤醒为止，t2被唤醒以后，会先加锁。接下来t2线程处于加锁状态，可以在解锁之后，再来执行B事件；而假如状态为B可执行，则t2线程处于加锁状态继续执行后续代码，也可以在解锁之后，再来执行B事件。
通过上面的筹划，可以保证无论t1和t2按照什么样的次序交织执行，A事件总是先完成，B事件总是后完成——纵然是比较极端的情况也是云云：比如t1一直占用CPU直到结束，那么t2占用CPU时，状态肯定是B可执行，则不会陷入等候；又比如t2先一直占用CPU，t2检查状态时会发现状态为B不可执行，就会阻塞在条件变量之上，如许就要等到A执行完成以后，才能醒来继续运行。
下面是具体条件变量相干接口：
  1. pthread_cond_t cond = PTHREAD_COND_INITIALIZER;//静态初始化
  2. int pthread_cond_init(pthread_cond_t *cond, pthread_condattr_t *cond_attr);//动态初始化
  3. int pthread_cond_signal(pthread_cond_t *cond); //唤醒一个线程
  4. int pthread_cond_broadcast(pthread_cond_t *cond);//唤醒所有线程
  5. int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);//等待
  6. int pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime);//具有超时时限的等待
  7. int pthread_cond_destroy(pthread_cond_t *cond);//条件变量销毁
复制代码


  • pthread_cond_t 是条件变量的数据类型，可以采用静态方式初始化，也可以使用 pthread_cond_init 进举措态初始化。
  • pthread_cond_wait 用于使本线程陷入阻塞，条件是自己必须处于加锁状态，pthread_cond_timedwait 效果类似，只不外可以指定一个最大超时时间。
  • pthread_cond_signal 和 pthread_cond_broadcast 分别采用单播和广播的形式唤醒阻塞在条件变量上的线程，值得注意的是这两个函数黑白阻塞的，所以如果调用时没有线程阻塞的话，将不会产生任何效果。
  • pthread_cond_destroy 可以用于烧毁条件变量。
以下是刚才示例的实现代码：
  1. typedef struct shareRes_s {
  2.         int flag; // flag 0 A可以执行 1 B可以执行
  3.     pthread_mutex_t mutex;
  4.     pthread_cond_t cond;
  5. } shareRes_t;
  7. void A(){
  8.     printf("Before A\n");
  9.     sleep(3);
  10.     printf("After A\n");
  11. }
  13. void B(){
  14.     printf("Before B\n");
  15.     sleep(3);
  16.     printf("After B\n");
  17. }
  19. void *threadFunc(void *arg){
  20.     sleep(5);
  21.     shareRes_t * pshareRes = (shareRes_t *)arg;
  22.     pthread_mutex_lock(&pshareRes->mutex);
  23.     if(pshareRes->flag != 1){
  24.             pthread_cond_wait(&pshareRes->cond,&pshareRes->mutex);
  25.     }
  26.     pthread_mutex_unlock(&pshareRes->mutex);
  27.     B();
  28.     pthread_exit(NULL);
  29. }
  31. int main(int argc, char *argv[])
  32. {
  33.     shareRes_t shareRes;
  34.     shareRes.flag = 0;
  35.     pthread_mutex_init(&shareRes.mutex, NULL);
  36.     pthread_cond_init(&shareRes.cond, NULL);
  37.     pthread_t tid;
  38.     pthread_create(&tid,NULL,threadFunc,&shareRes);
  39.     A();
  40.     pthread_mutex_lock(&shareRes.mutex);
  41.     shareRes.flag = 1;
  42.     pthread_cond_signal(&shareRes.cond);
  43.     pthread_mutex_unlock(&shareRes.mutex);
  44.     pthread_join(tid,NULL);
  45.     return 0;
  46. }
复制代码
下面是一个复杂的卖火车票的例子，我们除了拥有两个卖票窗口之外，还会有一个放票部门。
  1. typedef struct shareRes_s{
  2. pthread_mutex_t mutex;
  3. pthread_cond_t cond;
  4. int ticketNum;
  5. } shareRes_t, *pshareRes_t;
  7. void *sellTicket1(void *arg){
  8.     sleep(1);//让setTicket先抢到锁
  9.     pshareRes_t pshared = (pshareRes_t)arg;
  10.     while(1){
  11.         pthread_mutex_lock(&pshared->mutex);
  12.         if(pshared->ticketNum > 0){
  13.             printf("Before 1 sells tickets, ticketNum = %d\n", pshared->ticketNum);
  14.             --pshared->ticketNum;
  15.             if(pshared->ticketNum == 0){
  16.                 pthread_cond_signal(&pshared->cond);
  17.             }
  18.             usleep(500000);
  19.             printf("After 1 sells tickets, ticketNum = %d\n", pshared->ticketNum);
  20.             pthread_mutex_unlock(&pshared->mutex);
  21.             usleep(200000);//等待一会，让setTicket抢到锁
  22.             }else{
  23.             pthread_mutex_unlock(&pshared->mutex);
  24.             break;
  25.         }
  26.     }
  27.     pthread_exit(NULL);
  28. }
  30. void *sellTicket2(void *arg){
  31.     sleep(1);
  32.     pshareRes_t pshared = (pshareRes_t)arg;
  33.     while(1){
  34.         pthread_mutex_lock(&pshared->mutex);
  35.         if(pshared->ticketNum > 0){
  36.             printf("Before 2 sells tickets, ticketNum = %d\n", pshared->ticketNum);
  37.             --pshared->ticketNum;
  38.             if(pshared->ticketNum == 0){
  39.                     pthread_cond_signal(&pshared->cond);
  40.             }
  41.             usleep(500000);
  42.             printf("After 2 sells tickets, ticketNum = %d\n", pshared->ticketNum);
  43.             pthread_mutex_unlock(&pshared->mutex);
  44.             usleep(200000);
  45.         }else{
  46.             pthread_mutex_unlock(&pshared->mutex);
  47.             break;
  48.         }
  49.     }
  50.     pthread_exit(NULL);
  51. }
  53. void *setTicket(void *arg){
  54.     pshareRes_t pshared = (pshareRes_t)arg;
  55.     pthread_mutex_lock(&pshared->mutex);
  56.     if(pshared->ticketNum > 0){
  57.         printf("Set is waiting\n");
  58.         int ret = pthread_cond_wait(&pshared->cond,&pshared->mutex);
  59.         THREAD_ERROR_CHECK(ret,"pthread_cond_wait");
  60.     }
  61.     printf("add tickets\n");
  62.     pshared->ticketNum = 10;
  63.     pthread_mutex_unlock(&pshared->mutex);
  64.     pthread_exit(NULL);
  65. }
  67. int main()
  68. {
  69.     shareRes_t shared;
  70.     shared.ticketNum = 20;
  71.     int ret;
  72.     ret = pthread_mutex_init(&shared.mutex,NULL);
  73.     THREAD_ERROR_CHECK(ret,"pthread_mutex_init");
  74.     ret = pthread_cond_init(&shared.cond,NULL);
  75.     THREAD_ERROR_CHECK(ret,"pthread_cond_init");
  76.     pthread_t tid1,tid2,tid3;
  77.     pthread_create(&tid3,NULL,setTicket,(void *)&shared);//希望setTicket第一个执行
  78.     pthread_create(&tid1,NULL,sellTicket1,(void *)&shared);
  79.     pthread_create(&tid2,NULL,sellTicket2,(void *)&shared);
  80.     pthread_join(tid1,NULL);
  81.     pthread_join(tid2,NULL);
  82.     pthread_join(tid3,NULL);
  83.     pthread_cond_destroy(&shared.cond);
  84.     pthread_mutex_destroy(&shared.mutex);
  85.     return 0;
  86. }
复制代码
线程的属性

在线程创建的时候，用户可以给线程指定一些属性，用来控制线程的调理情况、CPU绑定情况、屏蔽、线程调用栈和线程分离等属性。这些属性可以通过一个 pthread_attr_t 类型的变量来控制，可以使用 pthread_attr_set 系列设置属性，然后可以传入 pthread_create 函数，从控制新建线程的属性。
在这里，我们以 pthread_attr_setdetachstate 为例子演示怎样设置线程的属性。
  1. void * threadFunc(void *arg){
  2.         return NULL;
  3. }
  5. int main()
  6. {
  7.     pthread_t tid;
  8.     pthread_attr_t tattr;
  9.     pthread_attr_init(&tattr);
  10.     pthread_attr_setdetachstate(&tattr,PTHREAD_CREATE_DETACHED);
  11.     int ret = pthread_create(&tid,&tattr,threadFunc,NULL);
  12.     THREAD_ERROR_CHECK(ret,"pthread_create");
  13.     ret = pthread_join(tid,NULL);
  14.     THREAD_ERROR_CHECK(ret,"pthread_join");
  15.     pthread_attr_destroy(&tattr);
  16.     return 0;
  17. }
复制代码
分离属性影响一个线程的终止状态是否能被其他线程使用 pthread_join 函数捕获终止状态。如果一个线程设置了分离属性，那么另一个线程使用 pthread_join 时会返回一个报错。
线程安全与可重入性

线程安全

由于多线程之间是共享同一个进程所在空间，所以多线程在访问共享数据的时候会出现竞争问题，这个问题不只会发生在用户自定义函数中，在一些库函数执行中也可能会出现竞争问题。有些库函数在筹划的时候会申请额外的内存，或者会在静态区域分配数据结构——一个典型的库函数就是 ctime 。 ctime函数会把日历时间字符串存储在静态区域。
  1. void * threadFunc(void *arg){
  2.     time_t now;
  3.     time(&now);
  4.     char *p = ctime(&now);
  5.     printf("child ptime = %s\n",p);
  6.     sleep(5);
  7.     printf("child ptime = %s\n",p);
  8.     pthread_exit(NULL);
  9. }
  11. int main()
  12. {
  13.     pthread_t tid;
  14.     int ret = pthread_create(&tid,NULL,threadFunc,NULL);
  15.     THREAD_ERROR_CHECK(ret,"pthread_create");
  16.     sleep(2);
  17.     time_t mainNow;
  18.     time(&mainNow);
  19.     printf("main time = %s\n",ctime(&mainNow));
  20.     ret = pthread_join(tid,NULL);
  21.     THREAD_ERROR_CHECK(ret,"pthread_join");
  22.     return 0;
  23. }
复制代码
在上述例子中的， p 指向的区域是静态的，所以纵然子线程没有作任何修改，但是由于主线程会调用 ctime 修改静态区域的字符串，子线程两次输出的结构会有差别。使用 ctime_r 可以制止这个问题， ctime_r 函数会增长一个额外指针参数，这个指针可以指向一个线程私有的数据，比如函数栈帧内，从而制止发生竞争问题。
  1. void *threadFunc(void *arg){
  2.     time_t now;
  3.     time(&now);
  4.     char buf[256];
  5.     char *p = ctime_r(&now,buf);
  6.     printf("child ptime = %s\n",p);
  7.     sleep(5);
  8.     printf("child ptime = %s\n",p);
  9.     pthread_exit(NULL);
  10. }
  12. int main()
  13. {
  14.     pthread_t tid;
  15.     int ret = pthread_create(&tid,NULL,threadFunc,NULL);
  16.     THREAD_ERROR_CHECK(ret,"pthread_create");
  17.     sleep(2);
  18.     char buf[256];
  19.     time_t mainNow;
  20.     time(&mainNow);
  21.     printf("main time = %s\n",ctime_r(&mainNow,buf));
  22.     ret = pthread_join(tid,NULL);
  23.     THREAD_ERROR_CHECK(ret,"pthread_join");
  24.     return 0;
  25. }
复制代码
类似于 ctime_r 这种函数是线程安全的，如果额外数据是分配在线程私有区域的情况下，在多线程的情况下并发地使用这些库函数是不会出现并发问题的。在资助手册中，库函数作者会说明线程的安全属性。
可重入性

在信号、多线程这些情况下，一个函数在执行过程中，有可能会异步地再重新调用同一个函数。如果重复的函数调用有可能会导致庞杂的结果，那么这些函数就是不可重入的。可重入函数和线程安全函数几乎是同义词的。下面是一个使用信号的情况下，可重入函数和不可重入函数的例子。
  1. char* funcA(int num)
  2. {
  3.     static char p[20]={0} ;
  4.     sprintf(p,"%d",num);
  5.     sleep(3);
  6.     return p;
  7. }
  9. //B函数可重入
  10. char* funcB(int num,char* p)
  11. {
  12.     sprintf(p,"%d",num);
  13.     sleep(3);
  14.     return p;
  15. }
  17. void sigFunc(int num)
  18. {
  19.     printf("signum=%d\n",num);
  20.     funcA(2);
  21.     char buf[64]={0};
  22.     funcB(3,buf);
  23. }
  25. int main()
  26. {
  27.     signal(2,sigFunc);
  28.     char* p;
  29.     p = funcA(1);
  30.     printf("p=%s\n",p);
  31.     char buf[64]={0};
  32.     p = funcB(1,buf);
  33.     printf("p=%s\n",p);
  34.     return 0;
  35. }
复制代码
理论上来说，实现可重入函数有下列需求：


  • 访问静态或者全局数据必须采取同步手段。
  • 不能调用非可重入函数。
一个比较典型的不可重入函数例子就是 malloc 函数， malloc 函数必然是要修改静态数据的，为了保证线程安全性， malloc 函数的实现当中会存在加锁和解锁的过程，假如 malloc 执行到加锁之后，解锁之前的时候，此时有信号产生并且递送的话，线程会转向执行信号处置惩罚回调函数，假如信号处置惩罚函数当中又调用了 malloc 函数，此时就会导致死锁——这就是 malloc 的不可重入性。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。
回复

使用道具 举报

0 个回复

倒序浏览
返回列表

快速回复

高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 or 立即注册

本版积分规则

风雨同行

金牌会员
这个人很懒什么都没写!

楼主热帖

标签云

挺好的 服务器
微信订阅号
微信服务号
微信客服
小程序
H5
关于我们 商务合作 网站地图
©Copyright 2022-2024 杭州祥升科技有限公司 版权所有 浙ICP备20004199号
快速回复 返回顶部 返回列表