使用编号来结束

好处是，完整执行程序后，再去判断是否该杀死

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#define PTH_NUMS 2
#define PTHEXIT  -1
typedef struct thread_args{pthread_t thrId;int thrNo;int fd;
}threadArg;
//结构体封装所有全局变量
struct global_vals{threadArg thr[2];int pth_exit_flag[PTH_NUMS];
}globalVal;//全局变量初始化为0
void print_err(int err,char* str){printf("%s:%s",str,strerror(err));exit(-1);
}
void *pthread_fun(void *arg){int fd=((threadArg *)arg)->fd;int thrNo=((threadArg*)arg)->thrNo;pthread_t thrId=((threadArg *)arg)->thrId;/*线程功能*/while(1){printf("线程号：%lu,线程编号：%d\n",thrId,thrNo);write(fd,"hello,",6);write(fd,"world\n",6);if(globalVal.pth_exit_flag[thrNo]) break;sleep(1);}return NULL;
}
void signal_fun(int signo){if(SIGALRM==signo){int i=0;for(;iglobalVal.pth_exit_flag[i]=PTHEXIT;pthread_cancel(globalVal.thr[i].thrId);}}
}
int main(void){int fd=open("./threadFile",O_CREAT|O_TRUNC|O_RDWR,0664);int i,ret;for(i=0;iglobalVal.thr[i].fd=fd;globalVal.thr[i].thrNo=i;ret=pthread_create(&globalVal.thr[i].thrId,NULL,\pthread_fun,(void *)&globalVal.thr[i]);if(ret!=0)print_err(ret,"pthread_create fails\n");}//定时10s，时间到后取消次线程signal(SIGALRM,signal_fun);alarm(10);//父线程while(1){printf("father\n");sleep(2);}return 0;
}

pthread_exit()

#include 
//线程调用这个函数时，可以主动退出（终止）
//返回值:成功返回0，失败返回非零错误号
//参数----------retval：线程结束时的返回值。
void pthread_exit(void *retval);
/*如果返回值很多时，就封装成一个结构体，返回结构体变量的地址即可*/

• 类似于exit函数，不过exit是终止整个进程的
• pthread_exit是终止次线程的

事实上:线程也可以通过调动return来退出（终止）

pthread_self()

#include 
//功能:线程获取自己的TID，类似于进程调用getpid()获取自己的PID一样
pthread_t pthread_self(void);
//返回值:成功返回线程TID，失败返回非零错误号。

使用：

 printf("fatherTid:%lu\n",pthread_self());//主线程TID

pthread_join()

#include 
/*功能：
阻塞等待tid为thread的次线程结束，结束时该函数会回收次线程所占用的所有资源（存储空间）
*/
//返回值:成功返回0，失败返回错误号
int pthread_join(pthread_t thread, void **retval);

这个函数只对次线程有意义，对主线程没有意义

• 因为主线程结束时整个进程就结束了，整个进程资源会由父进程回收

• 这个函数一般都是由主线程调用，以回收相关次线程的资源
• 当然次线程也是可以调用这个函数来回收其它次线程资源的

回收次线程资源原因

• 有些程序（进程）一旦运行后将会长期运行，不会结束
• 如果不回收，每结束一个次线程就导致一部分资源被占用
• 慢慢累积会使得整个进程资源越用越少，最好导致进程崩溃

说白了就是：次进程不断占据运行的进程的资源，最后过多而使得进程崩溃

参数:
（a）thread：指定要回收次线程的TID
（b）retval：次线程函数返回的返回值

``参数二取的是void * 返回值的地址，所以是两个*`

使用

 //次进程函数里面的返回值
//return NULL;pthread_exit((void *)10);

//循环接收次进程资源（阻塞）void *retval=NULL;for(i=0;ipthread_join(globalVal.thr[i].thrId,&retval);printf("%p\n",retval);}

​ 如果线程是被pthread_cancel取消掉的，自动返回-1

pthread_detach()

#include 
/*功能:如果次线程的资源不希望别人调用pthread_join函数来回收的话，而是希望自己在结束时，自动回收资源的话，就可以调用这个函数。
*/
//返回值:成功返回0，失败返回错误号
//参数:thread：你要分离的那个次线程的TID。
int pthread_detach(pthread_t thread);

这个函数的功能就是分离次线程，让次线程在结束时自动回收资源

使用：

 //次进程资源自动回收pthread_detach(globalVal.thr[i].thrId);

• pthread_join和pthread_detach作为两种不同的线程资源回收方式，只能二选一

注释代码的方式

注册进程退出处理函数

• 进程程在退出时会自动调用atexit();，实现进程的扫尾处理

回顾进程处理函数：atexit

void process_deal(){printf("\ndealing process!!\n");
}
//函数无返回值无传参

/*进程处理函数*/atexit(process_deal);

把ctrl+c变成正常退出

void signal_fun(int signo){if(SIGALRM==signo){int i=0;for(;iglobalVal.pth_exit_flag[i]=PTHEXIT;pthread_cancel(globalVal.thr[i].thrId);}}else if(signo==SIGINT){exit(0);}
}

signal(SIGINT,signal_fun);

• 线程也是这样

 #include 
//注册函数
void pthread_cleanup_push(void (*routine)(void *),void *arg);
void pthread_cleanup_pop(int execute);

1. pthread_cleanup_push

• 将类型为void (*routine)(void *)函数注册为“线程退出处理函数”

  注意第一个没*，第二个有*

• arg:传递给退出处理函数的参数

2. pthread_cleanup_pop

执行这个函数时，参数：

• 如果参数写!0

  会将压入栈中的推出处理函数地址弹出，然后调用退出函数进行线程的扫尾处理。

• 如果参数写0

  不弹出调用

    注册的原理就是将处理函数地址压入线程栈
----可以反复调用该函数注册多个退出处理函数，但是一般一个就够了----注册了多个线程退出处理函数的话，由于栈先进后出的特点注册压栈的顺序与弹栈调动的顺序刚好相反

有一个pthread_cleanup_push，就必须要对应有一个pthread_cleanup_pop

就算这个函数调用不到也必须写，否则编译时不通过

就像{}是成对出现的，缺一个都会报错

例子

/*线程退出处理函数*/
void pth_exit_deal(void* t_arg){printf("pthread %lu exit\n",((threadArg*)t_arg)->thrId);
}
/*进程函数*/
void *pthread_fun(void *arg){//注册 线程退出处理 函数pthread_cleanup_push(pth_exit_deal,arg);pthread_cleanup_pop(!0);pthread_exit((void *)10);
}

弹栈线程退出处理函数的几种条件

（a）调用thread_cleanup_pop(!0)，主动弹栈

（b）如果线程是被别人调用pthread_cancel取消的，也会弹栈

（c）如果线程是调用pthread_exit函数退出的，也会弹栈

如果线程时调用return退出的话，是不会自动弹栈的
要弹栈的话，必须主动调动thread_cleanup_pop(!0)			

线程的属性设置

就是pthreadcreate()的第二个参数不要写NULL

可以设置的线程属性

• 设置绑定属性
• 设置分离属性
• 设置线程堆栈属性
• 设置线程调度优先级属性

事实上默认属性所提供的功能就已经足够我们使用了，

C线程中设置属性的函数非常多，基本每一种属性都有独立的设置函数

例子：设置分离属性

将线程分离有两种方法：

• 调用pthread_detach函数实现

• 通过设置分离属性实现

  事实上使用pthread_detach()更方便些

分离属性设置的步骤:

1. 定义一个变量来存放新属性

   pthread_attr_t attr;//一个结构体，被typedef重命名了
   

2. 调用pthread_attr_init(&attr);初始化一下attr结构体变量

   int pthread_attr_init(pthread_attr_t *attr);
   //成功返回0，失败返回错误号
   

3. 调用pthread_attr_setdetachstate预设分离属性

   想设置什么类型属性就选择什么函数

   int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate);
   

   pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
   

   指定PTHREAD_CREATE_DETACHED宏后:

   pthread_attr_setdetachstate函数会自动的将:

   分离属性相关的数据设置到attr结构体变量的各个成员中

4. 调动pthread_create创建线程时，将attr传递给pthread_create，将线程分离

5. 删除属性设置

   int pthread_attr_destroy(pthread_attr_t *attr);
   //成功返回0，失败返回错误号
   

   #include 
   #include 
   #include 
   #include 
   #include 
   #include 
   #include 
   #include 
   #include 
   #include 
   #define PTH_NUMS 2
   #define PTHEXIT  -1
   typedef struct thread_args{pthread_t thrId;int thrNo;int fd;
   }threadArg;
   //结构体封装所有全局变量
   struct global_vals{threadArg thr[2];int pth_exit_flag[PTH_NUMS];pthread_attr_t attr;//设置线程属性
   }globalVal;//全局变量初始化为0
   void print_err(int err,char* str){printf("%s:%s",str,strerror(err));exit(-1);
   }
   /*线程退出处理函数*/
   void pth_exit_deal(void* t_arg){printf("pthread %lu exit\n",((threadArg*)t_arg)->thrId);
   }
   void *pthread_fun(void *arg){int fd=((threadArg *)arg)->fd;int thrNo=((threadArg*)arg)->thrNo;pthread_t thrId=((threadArg *)arg)->thrId;//pthread_detach(pthread_self());//注册 线程退出处理 函数pthread_cleanup_push(pth_exit_deal,arg);/*线程功能*/while(1){printf("线程号：%lu,线程编号：%d\n",thrId,thrNo);write(fd,"hello,",6);write(fd,"world\n",6);if(globalVal.pth_exit_flag[thrNo]) break;sleep(1);}//pthread_exit((void *)10);return NULL;pthread_cleanup_pop(!0);
   }
   void signal_fun(int signo){if(SIGALRM==signo){int i=0;for(;iglobalVal.pth_exit_flag[i]=PTHEXIT;//退出标志//pthread_cancel(globalVal.thr[i].thrId);//主动}}else if(signo==SIGINT){pthread_attr_destroy(&globalVal.attr);exit(0);}
   }
   void process_deal(){printf("\ndealing process!!\n");
   }
   int main(void){/*进程处理函数*/atexit(process_deal);int fd=open("./threadFile",O_CREAT|O_TRUNC|O_RDWR,0664);int i,ret;//属性初始化ret=pthread_attr_init(&globalVal.attr);if(ret!=0) print_err(ret,"attr fails\n");//设置分离属性pthread_attr_setdetachstate(&globalVal.attr,PTHREAD_CREATE_DETACHED);//线程初始化for(i=0;iglobalVal.thr[i].fd=fd;globalVal.thr[i].thrNo=i;ret=pthread_create(&globalVal.thr[i].thrId,\&globalVal.attr,\pthread_fun,(void *)&globalVal.thr[i]);//次进程资源自动回收pthread_detach(globalVal.thr[i].thrId);if(ret!=0)print_err(ret,"pthread_create fails\n");}//信号异常终止变成正常终止signal(SIGINT,signal_fun);//定时10s，时间到后取消次线程signal(SIGALRM,signal_fun);alarm(3);#if 0//循环接收次进程资源（阻塞）void *retval=NULL;for(i=0;ipthread_join(globalVal.thr[i].thrId,&retval);printf("%ld\n",(long)retval);}#endif//父线程while(1){printf("fatherTid:%lu\n",pthread_self());//主线程TIDsleep(2);}return 0;
   }