今天我们来学习下线程的相关函数
pthread_exit函数
将单个线程退出,类似与进程中的exit()函数。
函数原型:void pthread_exit(void *retval)。
参数:retval表示线程的退出状态,通常传NULL,当retval的值不为NULL时,其值由pthread_join函数接收。
思考:使用exit将指定线程退出,可以吗?
多线程环境中,应该尽量少用,或者不使用exit函数,取而代之使用pthread_exit函数将单个线程退出。任何线程中exit导致进程退出,其他线程未工作结束,主控线程退出时不能return或exit。pthread_exit或者return返回的指针所指向的内存单元。必须是全局的或者是用malloc分配的,不能在线程函数的栈上分配,因为当其它线程得到这个返回指针时线程函数已经退出了。
总结:
return:返回到调用者那里去,在主线程使用return会将整个进程退出。
pthread_exit():将调用该函数的线程退出(在主控线程使用只是将线程退出,而不是整个进程退出,在主线程中使用return会将整个进程退出,导致子线程来不及执行就结束了, 在主线程尽量不要要exit和return)
exit: 将进程退出,在线程中使用exit会导致整个进程退出,导致其他线程未执行, 所以在多线程编程统一使用pthread_exit()函数。
pthread_join()函数
阻塞等待线程退出,获取线程退出状态 , 其作用对应进程中 wait() 函数。
函数原型:int pthread_join(pthread_t thread, void **retval);
返回值:成功:0;失败:错误号
参数:thread:线程ID (【注意】:不是指针);retval:存储线程结束状态(pthread_exit(void*)retval)的值)。
对比记忆:
进程中:main返回值、exit参数-->int;等待子进程结束 waitpid 函数参数-->int * status
线程中:线程主函数返回值、pthread_exit-->void *;等待线程结束 pthread_join 函数参数-->void **retval
例程:参数 retval 非空用法,使用pthread_join回收pthread_exit()的退出值
#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
#include <stdlib.h>
typedef struct{
int a;
int b;
} exit_t;
void *tfn(void *arg)
{
exit_t *ret;
ret = malloc(sizeof(exit_t));
ret->a = 100;
ret->b = 300;
pthread_exit((void *)ret);
return NULL; //should not be here.
}
int main(void)
{
pthread_t tid;
exit_t *retval;
pthread_create(&tid, NULL, tfn, NULL);
/*调用pthread_join可以获取线程的退出状态*/
pthread_join(tid, (void **)&retval);
printf("a = %d, b = %d \n", retval->a, retval->b);
return 0;
}
总结:调用该函数的线程将挂起等待,直到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函数将循环创建的多个子线程回收。
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
int var = 100;
void *tfn(void *arg)
{
int i;
i = (int)arg;
sleep(i);
if (i == 1) { //i = 0 100 333 333 777 777
var = 333;
printf("var = %d\n", var);
pthread_exit((void *)var);
} else if (i == 3) {
var = 777;
printf("I'm %dth pthread, pthread_id = %lu\n var = %d\n", i+1, pthread_self(), var);
pthread_exit((void *)var);
} else {
printf("I'm %dth pthread, pthread_id = %lu\n var = %d\n", i+1, pthread_self(), var);
pthread_exit((void *)var);
}
return NULL;
}
int main(void)
{
pthread_t tid[5];
int i, *ret[5];
for (i = 0; i < 5; i++)
pthread_create(&tid[i], NULL, tfn, (void *)i);
for (i = 0; i < 5; i++) {
pthread_join(tid[i], (void **)&ret[i]);
printf("-------%d 's ret = %d\n", i, (int)ret[i]);
}
printf("I'm main pthread tid = %lu\t var = %d\n", pthread_self(), var);
pthread_exit(NULL);
}
pthread_detach()函数
实现线程分离。
线程分离状态:指定该状态,线程主动与主控线程断开关系。线程结束后,其退出状态不由其他线程获取,而直接自己自动释放。
网络、多线程服务器常用。
进程若有该机制,将不会产生僵尸进程。僵尸进程的产生主要由于进程死后,大部分资源被释放,一点残留资源仍存于系统中,
导致内核认为该进程仍存在。也可使用 pthread_create函数参2(线程属性)来设置线程分离。
函数原型:int pthread_detach(pthread_t thread);
返回值: 成功:0;失败:错误号
例程:使用pthread_detach函数实现线程分离
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>
#include <string.h>
void *tfn(void *arg)
{
int n = 3;
while (n--) {
printf("thread count %d\n", n);
sleep(1);
}
return (void *)1;
}
int main(void)
{
pthread_t tid;
void *tret;
int err;
#if 1
pthread_attr_t attr; /*通过线程属性来设置游离态,必须在在线程创建前设置属性*/
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
pthread_create(&tid, &attr, tfn, NULL);
pthread_attr_destroy(&attr);
#else
pthread_create(&tid, NULL, tfn, NULL);
pthread_detach(tid);
#endif
while (1) {
err = pthread_join(tid, &tret);
if (err != 0)
fprintf(stderr, "thread %s\n", strerror(err));
else
fprintf(stderr, "thread exit code %d\n", (int)tret);
sleep(1);
}
return 0;
}
总结:
1.一般情况下,线程终止后,其终止状态一直保留到其它线程调用pthread_join获取它的状态为止。但是线程也可以 被置为detach状态,这样的线程一旦终止就立刻回收它占用的 所有资源而不保留终止状态。
2.不能对一个已经处于detach状态的线程调用pthread_join,这样的调用将返回EINVAL。如果已经对一个线程调用了pthread_detach就不能再调用pthread_join了。
pthread_cancel()函数
杀死(取消)线程 ,其作用对应进程中 kill() 函数。
函数原型:int pthread_cancel(pthread_t thread);
返回值: 成功:0;失败:错误号
注意事项:线程的取消并不是实时的,而又一定的延时。需要等待线程到达某个取消点(检查点)。
类似于玩游戏存档,必须到达指定的场所(存档点,如:客栈、仓库、城里等)才能存储进度。杀死线程也不是立刻就能完成,必须要到达取消点。
取消点:是线程检查是否被取消,并按请求进行动作的一个位置。通常是一些系统调用creat,open,pause,close,read,write..... 可粗略认为一个系统调用(进入内核)即为一个取消点。
若线程主体函数长时间不会调用系统调用函数,可以自己手动添加取消点:pthread_testcancel(void); //自己添加取消点
pthread_setcancelstate函数
设置线程可取消和不可取消状态函数。
函数原型:int pthread_setcancelstate(int state,int *oldstate);
函数参数:state:分离属性,可分离或者不可分离,可以设置的参数为PTHREAD_CANCEL_ENABLE或者PTHREAD_CANCEL_DISABLE
oldstate:函数将当前可取消状态设置为state,而将原来的可取消状态保存在oldstate所指向的内存空间,这两步是原子操作, 不可分割,我们所默认的取消为推迟取消,即调用pthread_cancel函数后,在线程没有到达取消点之前,并不会取消。可以通过调用pthread_setcreatetype()来修改取消类型。
推迟取消或者异步取消oldtype:保存原来的状态
使用异步取消时,可以在任意时间撤销而不需要非要遇到取消点
例程:终止线程的三种方法。注意“取消点”的概念。return,pthread_exit,pthread_cancel
#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: I'm going to die 1 seconds after...\n");
// sleep(1);
pthread_testcancel(); //自己添加取消点
}
}
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, tfn2, NULL);
pthread_join(tid, &tret);
printf("thread 2 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;
}
总结:终止某个线程而不终止整个进程,有三种方法:
- 从线程主函数return。这种方法对主控线程不适用,从main函数return相当于调用exit。
- 一个线程可以调用pthread_cancel终止同一进程中的另一个线程。
- 线程可以调用pthread_exit终止自己。
线程属性初始化
注意:应先初始化线程属性,再pthread_ create 创建线程。
初始化线程属性。
函数原型:int pthread_attr_init(pthread_attr_t *attr);
成功: 0;失败:错误号。
销毁线程属性所占用的资源。
int pthread_attr_destroy(pthread_attr_t *attr);
成功: 0;失败:错误号
线程的分离状态
线程的分离状态决定一个线程以什么样的方式来终止自己。
非分离状态线程的默认属性是非分离状态,这种情况下,原有的线程等待创建的线程结束。只有当 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 (非分离线程)
例程:通过设置线程分离属性,创建分离子线程
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <pthread.h>
#include <string.h>
void *tfn(void *arg)
{
printf("thread: pid = %d, tid = %lu\n", getpid(), pthread_self());
return NULL ;
}
int main(void)
{
pthread_t tid;
pthread_attr_t attr;
int ret=pthread_attr_init(&attr);
if(ret!=0)
{
fprintf(stderr,"attr_init error:%s\n",strerror(ret));
exit(1);
}
ret=pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_DETACHED);//设置线程属性
为,分离属性
if(ret!=0)
{
fprintf(stderr, "attr_setdetachstate error:%s\n",strerror(ret));
exit(1);
}
ret = pthread_create(&tid, &attr, tfn, NULL);
if(ret!=0)
{
perror("pthread_create error");
exit(1);
}
ret = pthread_attr_destroy(&attr);
if(ret!=0)
{
fprintf(stderr, "attr_ destroy error:%s\n",strerror(ret));
exit(1);
}
ret=pthread_join(tid, NULL);
printf("thread_join() ret = %d\n",ret);
if(ret!=0)
{
fprintf(stderr, "thread_join error:%s\n",strerror(ret));
exit(1);
}
printf("main: pid = %d, tid = %lu\n", getpid(), pthread_self());
return 0;
}