linux系统编程(十)守护进程、线程(下)

简介: 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.信号的复杂语义很难和多线程共存,应避免在多线程引入信号机制

相关文章
|
8天前
|
安全 Java 开发者
Java并发编程中的线程安全性与性能优化
在Java编程中,处理并发问题是至关重要的。本文探讨了Java中线程安全性的概念及其在性能优化中的重要性。通过深入分析多线程环境下的共享资源访问问题,结合常见的并发控制手段和性能优化技巧,帮助开发者更好地理解和应对Java程序中的并发挑战。 【7月更文挑战第14天】
|
5天前
|
Linux
Linux —— 进程间通信
Linux —— 进程间通信
11 1
|
8天前
|
监控 Java API
Java并发编程之线程池深度解析
【7月更文挑战第14天】在Java并发编程领域,线程池是提升性能、管理资源的关键工具。本文将深入探讨线程池的核心概念、内部工作原理以及如何有效使用线程池来处理并发任务,旨在为读者提供一套完整的线程池使用和优化策略。
|
10天前
|
Unix Linux
linux进程状态基本语法
linux进程状态基本语法
|
10天前
|
安全 算法 Linux
【Linux】线程安全——补充|互斥、锁|同步、条件变量(下)
【Linux】线程安全——补充|互斥、锁|同步、条件变量(下)
19 0
|
10天前
|
存储 安全 Linux
【Linux】线程安全——补充|互斥、锁|同步、条件变量(上)
【Linux】线程安全——补充|互斥、锁|同步、条件变量(上)
15 0
|
10天前
|
缓存 Linux 编译器
【Linux】多线程——线程概念|进程VS线程|线程控制(下)
【Linux】多线程——线程概念|进程VS线程|线程控制(下)
22 0
|
10天前
|
存储 Linux 调度
【Linux】多线程——线程概念|进程VS线程|线程控制(上)
【Linux】多线程——线程概念|进程VS线程|线程控制(上)
29 0
|
10天前
|
存储 NoSQL Unix
【Linux】进程信号(下)
【Linux】进程信号(下)
21 0
|
10天前
|
安全 Linux Shell
【Linux】进程信号(上)
【Linux】进程信号(上)
16 0