线程的标识、创建和终止

1.线程标识

就像每个进程都有一个进程ID一样,每个线程都有一个线程ID。进程ID在整个系统中是唯一的,但线程ID只在它所属的进程环境中有效。
线程ID使用pthread_t数据类型来表示,实现的时候可以使用一个结构来表示pthread_t数据类型,所以可移植的操作系统实现不能将它比作整数处理。因此必须使用函数来对比线程ID进行比较。
#include <pthread.h>  
int pthread_equal(pthread_t tid1, pthread_t tid2); //如果相等返回非0值,否则返回0. 
线程可以通过调用pthread_self函数获得自身线程ID。
#include<pthread.h>  
pthread_t pthread_self(void); //返回值为调用线程的线程ID。  

2.线程的创建

在传统的UNIX进程模型中,每个进程只有一个控制线程,从概念上讲,这与基于线程模型中每个进程只包含一个线程是相同的。在POSIX线程(pthread)的情况下,程序开始运行时,它也是以单进程中的单个控制线程启动的,在创建多个控制线程以前,程序的行为与传统的进程没有什么区别,新增的线程可以通过调用pthread_create函数创建。
#include<pthread.h>  
int pthread_create(pthread_t *restrict tidp, const pthread_attr_t *restrict attr, void *(*start_rtn)(void*), void*restrict arg );  
//若成功则返回0,否则返回错误编号  
当pthread_create成功返回时,由tidp指向的内存单元被设置为新创建线程的线程ID,attr参数用于定制各种不同的线程属性。新创建的线程从start_rtn函数的地址开始运行,该函数只有一个无类型指针参数arg,如果需要向start_rtn函数传递的参数不止一个,需要把这些参数放到一个结构体中,然后作为arg参数传入。
线程创建时并不能保证哪个线程会先运行,新创建的线程可以访问进程的地址空间,并且继承调用点的浮点环境和信号屏蔽字,但是该线程的未决信号集被清除。
注意:pthread函数在调用失败后通常返回错误码,它们并不像其他POSIX函数一样设置errno,所以通常使用strerror函数将错误代码翻译成描述信息,而不能直接使用perror函数取errno进行翻译。
 

3.线程终止

如果进程中任一线程调用了exit,_Exit或者_exit,那么整个进程就会终止。如果信号的默认动作是终止进程,那么把该信号发送到线程会终止整个进程。
单个线程可以通过下列三种方式退出,在不终止整个进程的情况下停止它的控制流。
1.线程只是从启动例程中返回,返回值是线程的退出码。
2.线程可以被同一进程中的其他线程取消。
3.线程调用pthread_exit。
#include<pthread.h>  
void pthread_exit(void *rval_ptr);  
rval_ptr是一个无类型指针,与传给启动例程的单个参数类似,进程中的其他线程可以通过调用pthread_join函数访问到这个指针。
#include <pthread.h>  
int pthread_join(pthread_t thread, void **rval_ptr); //若成功则返回0,否则返回错误编号。  
调用线程将一直阻塞,直到指定的线程调用pthread_exit、从启动例程中返回或者取消。如果线程只是从它的启动例程返回,rval_ptr将包含返回码。如果线程被取消,由rval_ptr指定的内容单元就置为PTHREAD_CANCELED。
如果对线程的返回值不感兴趣,可以把rval_ptr置为NULL。 
实践:
#include <stdio.h>  
#include <pthread.h>  
#include <string.h>  
  
void* thr_fn1(void *arg){  
        printf("thread 1 return.\n");  
        return (void*)1;  
}  
  
void* thr_fn2(void *arg){  
        printf("thread 2 exit.\n");  
        pthread_exit((void*)2);  
}  
  
int main(void){  
        int err;  
        pthread_t tid1,tid2;  
        void* tret;  
  
        err = pthread_create(&tid1, NULL, thr_fn1, NULL);  
        if(err != 0){  
                printf("pthread_create:%s\n",strerror(err));  
                return -1;  
        }  
  
        err = pthread_create(&tid2, NULL, thr_fn2, NULL);  
        if(err != 0){  
                printf("pthread_create:%s\n",strerror(err));  
                return -1;  
        }  
  
        err = pthread_join(tid1, &tret);  
        if(err != 0){  
                printf("pthread_join:%s\n",strerror(err));  
                return -1;  
        }  
        printf("thread1 exit code %d\n",(int)tret);  
  
        err = pthread_join(tid2, &tret);  
        if(err != 0){  
                printf("pthread_join:%s\n",strerror(err));  
                return -1;  
        }  
        printf("thread1 exi2 code %d\n",(int)tret);  
  
        return 0;  
}  

编译:

gcc -pthread thread.c UNIX原生是不支持多线程的,多线程通过lpthread库实现,所以需要使用lpthread库进行编译。
执行:
thread 2 exit.
thread 1 return.
thread1 exit code 1
thread1 exi2 code 2 
pthread_create和pthread_exit函数的无类型指针参数能传递的参数值可以不止一个,该指针可以传递包含更复杂信息的结构体地址(这就是为什么pthread_join中的rval_ptr的类型为双指针),但是要保证结构体使用的内存在调用者完成后必须仍然是有效的。线程可以通过调用pthread_cancel函数来请求取消同一进程中的其他线程。
#include<pthread.h>  
int pthread_cancel(pthread_t tid); //若成功则返回0,否则返回错误编号
默认情况下,pthread_cancel函数会使得由tid标识的线程的行为表现为如同调用了参数为PTHREAD_CANCELED的pthread_exit
函数,但是线程可以忽略取消方式或者控制取消方式。 
线程可以安排它退出时需要调用的函数,这与进程的atexit函数是类型的。这样的函数称为线程清理处理程序,线程可以建立多个清理处理程序,处理程序记录在栈中,也就是说他们的执行顺序与他们注册时的顺序相反。
#include<pthread.h>  
void pthread_cleanup_push(void (*rtn)(void *), void* arg);  
void pthread_cleanup_pop(int execute);  
当线程执行以下动作时调用清理函数,调用参数为arg,清理函数rtn的调用顺序是由pthread_cleanup_push函数来安排的。
1.调用pthread_exit时。
2.响应取消请求时。
3.用非零execute参数调用pthread_cleanup_pop时。
如果execute参数置为0,清理函数将不被调用。无论execute参数是否为0,pthread_cleanup_pop都将删除上次pthread_cleanup_push调用建立的清理处理程序。 
使用这两个函数有以下注意点:
1.push和pop一定是成对出现的。
2.push可以有多个,同样pop也要有对应的数量。
 
实践:
#include <stdio.h>  
#include <pthread.h>    
void cleanup(void *arg){  
        printf("cleanup:%s\n",(char*)arg);  
}  
  
void *thr_fn1(void *arg){  
        printf("thread 1 start\n");  
        pthread_cleanup_push(cleanup, "thread 1 first handler");  
        pthread_cleanup_push(cleanup, "thread 1 second handler");  
        printf("thread 1 push complete\n");  
        return (void *)1;  
        pthread_cleanup_pop(0);  
        pthread_cleanup_pop(0);  
}  
  
void *thr_fn2(void *arg){  
        printf("thread 2 start\n");  
        pthread_cleanup_push(cleanup, "thread 2 first handler");  
        pthread_cleanup_push(cleanup, "thread 2 second handler");  
        printf("thread 2 push complete\n");  
        pthread_exit((void *)2);  
        pthread_cleanup_pop(0);  
        pthread_cleanup_pop(0);  
}  
  
int main(void){  
        pthread_t tid1,tid2;  
        int err;  
        void* tret;  
  
        err = pthread_create(&tid1, NULL, thr_fn1, (void*)1);  
        if(err != 0){  
                printf("pthread_create:%s\n",strerror(err));  
                return -1;  
        }  
  
        err = pthread_create(&tid2, NULL, thr_fn2, (void*)2);  
        if(err != 0){  
                printf("pthread_create:%s\n",strerror(err));  
                return -1;  
        }  
  
        err = pthread_join(tid1,&tret);  
        if(err != 0){  
                printf("pthread_join:%s\n",strerror(err));  
                return -1;  
        }  
        printf("thread 1 exit code:%d\n",(int)tret);  
  
        err = pthread_join(tid2,&tret);  
        if(err != 0){  
                printf("pthread_join:%s\n",strerror(err));  
                return -1;  
        }  
        printf("thread 2 exit code:%d\n",(int)tret);  
  
        return 0;  
}  
可能大家会有疑问:
thr_fn1和thr_fn2中的pthread_cleanup_pop不是执行不到了么?是的,但是如果不写,会有语法错误,编译不会通过。因为push和pop必须成对出现。
 
运行结果:
thread 2 start
thread 2 push complete
cleanup:thread 2 second handler
cleanup:thread 2 first handler
thread 1 start
thread 1 push complete
thread 1 exit code:1
thread 2 exit code:2
从结果来看,只有调用了pthread_exit函数后才能调用清理函数。
 
现在可以看出,线程和进程函数有很多相似之处。
 
在默认情况下,线程终止状态会保存到对该线程调用pthread_join,如果线程已经处于分离状态,线程的底层存储资源可以在线程终止时立即被收回。当线程被分离时,并不能用pthread_join函数等待它的终止状态,对分离状态的线程进行pthread_join的调用会产生失败,返回EINVAL。pthread_detach调用可以用于线程进入分离状态。
#include <pthread.h>  
int pthread_detach(pthread_t tid); //成功则返回1,否则返回错误编号。   
实践:
#include <stdio.h>  
#include <pthread.h>  
#include <string.h>  
  
void *thr_fn(void *arg){  
        printf("thread start\n");  
        printf("thread complete\n");  
        pthread_exit((void *)1);  
}  
  
int main(void){  
        pthread_t tid1;  
        int err;  
        void* tret;    
        err = pthread_create(&tid1, NULL, thr_fn, (void*)1);  
        if(err != 0){  
                printf("pthread_create:%s\n",err);  
                return -1;  
        }    
        err = pthread_detach(tid1);  
        if(err != 0){  
                printf("pthread_detach:%s\n",err);  
                return -1;  
        }  
  
        err = pthread_join(tid1,&tret);  
        if(err != 0){  
                printf("pthread_join:%s\n",strerror(err));  
                return -1;  
        }  
        printf("thread 1 exit code:%d\n",(int)tret);  
        return 0;  
}  
运行结果:
pthread_join:Invalid argument
因为线程已经处于分离状态,所以无法获取终止状态。
posted @ 2015-06-26 16:32  neteasefans  阅读(596)  评论(0编辑  收藏  举报