linux系统编程（十）守护进程、线程（下）-阿里云开发者社区

【练习】：创建一个新线程，打印线程ID。注意：链接线程库 -lpthread      
【pthrd_crt.c】
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <pthread.h>
void sys_err(const char *str)
{
        perror(str);
        exit(1);
}
void *tfn(void *arg){
        printf("main:pid = %d,tid = %lu\n",getpid(),pthread_self());
        return NULL;
}
int main(int argc,char *argv[])
{
        pthread_t tid;
        tid = pthread_self();
        printf("main:pid = %d,tid = %lu\n",getpid(),tid);
        int ret = pthread_create(&tid,NULL,tfn,NULL);
        if(ret!=0){
                perror("pthread_create error");
        }
         printf("main:pid = %d,tid = %lu\n",getpid(),tid);
        sleep(1);
        由于pthread_create的错误码不保存在errno中，因此不能直接用perror(3)打印错误信息，可以先用strerror(3)把错误码转换成错误信息再打印。如果任意一个线程调用了exit或_exit，则整个进程的所有线程都终止，由于从main函数return也相当于调用exit，为了防止新创建的线程还没有得到执行就终止，我们在main函数return之前延时1秒，这只是一种权宜之计，即使主线程等待1秒，内核也不一定会调度新创建的线程执行，下一节我们会看到更好的办法。
【练习】：循环创建多个线程，每个线程打印自己是第几个被创建的线程。(类似于进程循环创建子进程)                          
【more_pthrd.c】
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <pthread.h>
void sys_err(const char *str)
{
    perror(str);
    exit(1);
}
void *tfn(void *arg)
{
    int i = (int)arg;
    sleep(i);
    printf("---i'm %dth thread :pid = %d,tid = %lu\n",i+1,getpid(),pthread_self());
    return  NULL;
}
int main(int argc,char *argv[])
{
    int i;
    int ret;
    pthread_t tid;
    for(i=0;i<5;i++){
  ret = pthread_create(&tid,NULL,tfn,(void *)i);
  if(ret != 0){
    sys_err("pthread_create error");
  }
    }
    sleep(i);
    printf("---i'm main :pid = %d,tid = %lu\n",getpid(),pthread_self());
    return 0;
}

拓展思考：将pthread_create函数参4修改为(void *)&i, 将线程主函数内改为 i=*((int *)arg)

是否可以？

这里涉及到了引用，也间接证明C++的重要性。

1.4.2.1 线程与共享

线程间共享全局变量！

【牢记】：线程默认共享数据段、代码段等地址空间，常用的是全局变量。而进程不共享全局变量，只能借助mmap。
【练习】：设计程序，验证线程之间共享全局数据。             
【glb_var_pthrd.c】
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <pthread.h>
void sys_err(const char *str)
{
    perror(str);
    exit(1);
}
int var = 100;
void *tfn(void *arg)
{
    var = 200;
    printf("thread ,var=%d\n",var);
    return  NULL;
}
int main(int argc,char *argv[])
{
    int ret;
    printf("At first var =%d\n",var);
    pthread_t tid;
    ret = pthread_create(&tid,NULL,tfn,NULL);
    if(ret != 0){
    sys_err("pthread_create error");
  }
    sleep(1);
    printf("-after pthread_create,var = %d\n",var);
    return 0;
}

1.4.3 pthread_exit函数

将单个线程退出

void pthread_exit(void *retval);  
参数：
  retval表示线程退出状态，通常传NULL

思考：使用exit将指定线程退出，可以吗？  
===========================================================================    
【练习】：编写多线程程序，总结exit、return、pthread_exit各自退出效果。
  return：返回到调用者那里去。
  pthread_exit()：将调用该函数的线程退出    
  exit: 将进程退出。  
  ===========================================================================        
【pthrd_exit.c】
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <pthread.h>
void sys_err(const char *str)
{
  perror(str);
  exit(1);
}
void func(void)
{
  pthread_exit(NULL);
  return ;
}
void *tfn(void *arg)
{
  int i=(int)arg;
  sleep(i);
  if(i == 2)
  {
  //exit(0);
  //return NULL;
  //func();
  pthread_exit(NULL);
  }
  printf("---i'm %dth thread :pid = %d,tid = %lu\n",i+1,getpid(),pthread_self());
  return  NULL;
}
int main(int argc,char *argv[])
{
  int i;
  int ret;
  pthread_t tid;
  for(i=0;i<5;i++){
  ret = pthread_create(&tid,NULL,tfn,(void *)i);
  if(ret != 0){
    sys_err("pthread_create error");
  }
  }
  printf("---i'm main :pid = %d,tid = %lu\n",getpid(),pthread_self());
  pthread_exit((void *)0);
}

结论：线程中，禁止使用exit函数，会导致进程内所有线程全部退出。

在不添加sleep控制输出顺序的情况下。pthread_create在循环中，几乎瞬间创建5个线程，但只有第1个线程有机会输出（或者第2个也有，也可能没有，取决于内核调度）如果第3个线程执行了exit，将整个进程退出了，所以全部线程退出了。

所以，多线程环境中，应尽量少用，或者不使用exit函数，取而代之使用pthread_exit函数，将单个线程退出。任何线程里exit导致进程退出，其他线程未工作结束，主控线程退出时不能return或exit。

另注意，pthread_exit或者return返回的指针所指向的内存单元必须是全局的或者是用malloc分配的，不能在线程函数的栈上分配，因为当其它线程得到这个返回指针时线程函数已经退出了。

1.4.4 pthread_join 函数

阻塞等待线程退出，获取线程退出状态其作用，对应进程中 waitpid() 函数。

int pthread_join(pthread_t thread, void **retval); 
成功：0；
失败：错误号
  参数：thread：线程ID （【注意】：不是指针）；
   retval：存储线程结束状态。
  对比记忆：
  进程中：main返回值、exit参数-->int；等待子进程结束 wait 函数参数-->int *
  线程中：线程主函数返回值、pthread_exit-->void *；等待线程结束 pthread_join 函数参数-->void **

【练习】
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <pthread.h>
struct thrd{
  int var;
  char str[256];
};
void sys_err(const char *str){
  perror(str);
  exit(1);
}
void *tfn(void *arg)
{
  struct thrd *tval;
  tval = malloc(sizeof(tval));
  tval->var = 100;
  strcpy(tval->str,"hello thread");
  return (void *)tval;
}
int main(int argc,char *argv[])
{
  pthread_t tid;
  struct thrd *retval;
  int ret = pthread_create(&tid,NULL,tfn,NULL);
  if(ret != 0)
  sys_err("pthread_create error");
  //int pthread_join(pthread_t thread,void **retval);
  ret = pthread_join(tid,(void **)&retval);
  if(ret!=0)
  sys_err("pthread_join error");
  printf("child thread exit with var = %d,str = %s\n",retval->var,retval->str);
  pthread_exit(NULL);
}

调用该函数的线程将挂起等待，直到id为thread的线程终止。thread线程以不同的方法终止，通过pthread_join得到的终止状态是不同的，总结如下：

1.如果thread线程通过return返回，retval所指向的单元里存放的是thread线程函数的返回值。

2.如果thread线程被别的线程调用pthread_cancel异常终止掉，retval所指向的单元里存放的是常数PTHREAD_CANCELED。

3.如果thread线程是自己调用pthread_exit终止的，retval所指向的单元存放的是传给pthread_exit的参数。

4.如果对thread线程的终止状态不感兴趣，可以传NULL给retval参数。

【练习】：使用pthread_join函数将循环创建的多个子线程回收。      
【pthrd_loop_join.c】

1.4.5 pthread_detach函数

实现线程分离

int pthread_detach(pthread_t thread); 
成功：0；
失败：错误号

线程分离状态：指定该状态，线程主动与主控线程断开关系。线程结束后，其退出状态不由其他线程获取，而直接自己自动释放。网络、多线程服务器常用。

进程若有该机制，将不会产生僵尸进程。僵尸进程的产生主要由于进程死后，大部分资源被释放，一点残留资源仍存于系统中，导致内核认为该进程仍存在。

也可使用 pthread_create函数参2(线程属性)来设置线程分离。

【练习】：使用pthread_detach函数实现线程分离           
【pthrd_detach.c】

一般情况下，线程终止后，其终止状态一直保留到其它线程调用pthread_join获取它的状态为止。但是线程也可以被置为detach状态，这样的线程一旦终止就立刻回收它占用的所有资源，而不保留终止状态。

不能对一个已经处于detach状态的线程调用pthread_join，这样的调用将返回EINVAL错误。也就是说，如果已经对一个线程调用了pthread_detach就不能再调用pthread_join了。

1.4.6 pthread_cancel函数

杀死(取消)线程其作用，对应进程中 kill() 函数。

int pthread_cancel(pthread_t thread); 
成功：0；
失败：错误号

【注意】：线程的取消并不是实时的，而有一定的延时。需要等待线程到达某个取消点(检查点)。

类似于玩游戏存档，必须到达指定的场所(存档点，如：客栈、仓库、城里等)才能存储进度。杀死线程也不是立刻就能完成，必须要到达取消点。

取消点：

是线程检查是否被取消，并按请求进行动作的一个位置。

通常是一些系统调用creat，open，pause，close，read，write…

执行命令man 7 pthreads可以查看具备这些取消点的系统调用列表。也可参阅 APUE.12.7 取消选项小节。

可粗略认为一个系统调用(进入内核)即为一个取消点。如线程中没有取消点，可以通过调用pthread_testcancel函数自行设置一个取消点。

被取消的线程，退出值定义在Linux的pthread库中。常数PTHREAD_CANCELED的值是-1。可在头文件pthread.h中找到它的定义：#define PTHREAD_CANCELED ((void *) -1)。因此当我们对一个已经被取消的线程使用pthread_join回收时，得到的返回值为-1。

【练习】：终止线程的三种方法。注意“取消点”的概念。          
【pthrd_endof3.c】  
#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
#include <stdlib.h>
void *tfn1(void *arg)
{
  printf("thread 1 returning\n");
  return (void *)111;
}
void *tfn2(void *arg)
{
  printf("thread 2 exiting\n");
  pthread_exit((void *)222);
}
void *tfn3(void *arg)
{
  while(1){
  //  printf("thread 3:iam going to die in3 seconds ...\n");
  //  sleep(1);
  pthread_testcancel();
  }
  return (void *)666;
}
int main(void)
{
  pthread_t tid;
  void *tret = NULL;
  pthread_create(&tid,NULL,tfn1,NULL);
  pthread_join(tid,&tret);
  printf("thread 1 exit code = %d\n\n",(int)tret);
  pthread_create(&tid,NULL,tfn1,NULL);
        pthread_join(tid,&tret);
        printf("thread 1 exit code = %d\n\n",(int)tret);
  pthread_create(&tid,NULL,tfn3,NULL);
  sleep(3);
  pthread_cancel(tid);
  pthread_join(tid,&tret);
  printf("thread 3 exit code = %d\n",(int)tret);
  return 0;
}

1.4.6.1 终止线程方式

总结：终止某个线程而不终止整个进程，有三种方法：

1.从线程主函数return。这种方法对主控线程不适用，从main函数return相当于调用exit。

2.一个线程可以调用pthread_cancel终止同一进程中的另一个线程。

3.线程可以调用pthread_exit终止自己。

1.4.7 控制原语对比

进程            线程
  fork    pthread_create
  exit    pthread_exit
  wait    pthread_join
  kill    pthread_cancel
  getpid      pthread_self  命名空间
  ***    pthread_detach

1.5 线程属性

本节作为指引性介绍，linux下线程的属性是可以根据实际项目需要，进行设置，之前我们讨论的线程都是采用线程的默认属性，默认属性已经可以解决绝大多数开发时遇到的问题。如我们对程序的性能提出更高的要求那么需要设置线程属性，比如可以通过设置线程栈的大小来降低内存的使用，增加最大线程个数。

typedef struct 
{
int      detachstate;  //线程的分离状态
int      schedpolicy;  //线程调度策略
struct sched_param  schedparam;  //线程的调度参数
int      inheritsched;  //线程的继承性
int      scope;   //线程的作用域
size_t      guardsize;  //线程栈末尾的警戒缓冲区大小
int     stackaddr_set; //线程的栈设置
void*     stackaddr;  //线程栈的位置
size_t      stacksize;  //线程栈的大小
} pthread_attr_t; 
主要结构体成员：
  1. 线程分离状态
  2. 线程栈大小（默认平均分配）
  3. 线程栈警戒缓冲区大小（位于栈末尾）          
参 APUE.12.3 线程属性

属性值不能直接设置，须使用相关函数进行操作，初始化的函数为pthread_attr_init，这个函数必须在pthread_create函数之前调用。之后须用pthread_attr_destroy函数来释放资源。

线程属性主要包括如下属性：作用域（scope）、栈尺寸（stack size）、栈地址（stackaddress）、优先级（priority）、分离的状态（detached state）、调度策略和参数（scheduling policy and parameters）。默认的属性为非绑定、非分离、缺省的堆栈、与父进程同样级别的优先级。

1.5.1 线程属性初始化

注意：应先初始化线程属性，再pthread_create创建线程

初始化线程属性
int pthread_attr_init(pthread_attr_t *attr); 
成功：0；
失败：错误号 
============================================================================
销毁线程属性所占用的资源
int pthread_attr_destroy(pthread_attr_t *attr); 
成功：0；
失败：错误号

1.5.2 线程的分离状态

线程的分离状态决定一个线程以什么样的方式来终止自己。

非分离状态：

线程的默认属性是非分离状态，这种情况下，原有的线程等待创建的线程结束。只有当pthread_join()函数返回时，创建的线程才算终止，才能释放自己占用的系统资源。

分离状态：

分离线程没有被其他的线程所等待，自己运行结束了，线程也就终止了，马上释放系统资源。应该根据自己的需要，选择适当的分离状态。

线程分离状态的函数：
设置线程属性，分离or非分离
int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate); 
获取线程属性，分离or非分离
int pthread_attr_getdetachstate(pthread_attr_t *attr, int *detachstate); 
参数： 
  attr：已初始化的线程属性
  detachstate：  
  PTHREAD_CREATE_DETACHED（分离线程）
  PTHREAD _CREATE_JOINABLE（非分离线程）

这里要注意的一点是，如果设置一个线程为分离线程，而这个线程运行又非常快，它很可能在pthread_create函数返回之前就终止了，它终止以后就可能将线程号和系统资源移交给其他的线程使用，这样调用pthread_create的线程就得到了错误的线程号。要避免这种情况可以采取一定的同步措施，最简单的方法之一是可以在被创建的线程里调用pthread_cond_timedwait函数，让这个线程等待一会儿，留出足够的时间让函数pthread_create返回。设置一段等待时间，是在多线程编程里常用的方法。但是注意不要使用诸如wait()之类的函数，它们是使整个进程睡眠，并不能解决线程同步的问题。

1.5.3 线程属性控制示例

#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <pthread.h>
#define SIZE 0x100000
void *th_fun(void *arg)
{
  while (1) 
  sleep(1);
}
int main(void)
{
  pthread_t tid;
  int err, detachstate, i = 1;
  pthread_attr_t attr;
  size_t stacksize;
  void *stackaddr;
  pthread_attr_init(&attr);  
  pthread_attr_getstack(&attr, &stackaddr, &stacksize);
  pthread_attr_getdetachstate(&attr, &detachstate);
  if (detachstate == PTHREAD_CREATE_DETACHED)
  printf("thread detached\n");
  else if (detachstate == PTHREAD_CREATE_JOINABLE)
  printf("thread join\n");
  else
  printf("thread unknown\n");
  pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
  while (1) {
  stackaddr = malloc(SIZE);
  if (stackaddr == NULL) {
    perror("malloc");
    exit(1);
  }
  stacksize = SIZE;
  pthread_attr_setstack(&attr, stackaddr, stacksize);
  err = pthread_create(&tid, &attr, th_fun, NULL);
  if (err != 0) {
    printf("%s\n", strerror(err));
    exit(1);
  }
  printf("%d\n", i++);
  }
  pthread_attr_destroy(&attr);
  return 0;
}  
【pthrd_attr_change.c】

1.6 线程使用注意事项

1.主线程退出其他线程不退出，主线程应调用pthread_exit

2.避免僵尸线程 pthread_join pthread_detach pthread_create指定分离属性被join线程可能在join函数返回前就释放完自己的所有内存资源，所以不应当返回被回收线程栈中的值;

3.malloc和mmap申请的内存可以被其他线程释放

4.应避免在多线程模型中调用fork除非，马上exec，子进程中只有调用fork的线程存在，其他线程在子进程中均pthread_exit

5.信号的复杂语义很难和多线程共存，应避免在多线程引入信号机制

linux系统编程（十）守护进程、线程（下）

1.4.2.1 线程与共享

1.4.3 pthread_exit函数

1.4.4 pthread_join 函数

1.4.5 pthread_detach函数

1.4.6 pthread_cancel函数

1.4.6.1 终止线程方式

1.4.7 控制原语对比

1.5 线程属性

1.5.1 线程属性初始化

1.5.2 线程的分离状态

1.5.3 线程属性控制示例

1.6 线程使用注意事项

热门文章

最新文章

相关课程

相关电子书

相关实验场景

推荐镜像

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

linux系统编程（十）守护进程、线程（下）

1.4.2.1 线程与共享

1.4.3 pthread_exit函数

1.4.4 pthread_join 函数

1.4.5 pthread_detach函数

1.4.6 pthread_cancel函数

1.4.6.1 终止线程方式

1.4.7 控制原语对比

1.5 线程属性

1.5.1 线程属性初始化

1.5.2 线程的分离状态

1.5.3 线程属性控制示例

1.6 线程使用注意事项

热门文章

最新文章

相关课程

相关电子书

相关实验场景

推荐镜像