Linux线程在核内是以轻量级进程的形式存在的，拥有独立的进程表项，而所有的创建、同步、删除等操作都在核外pthread库中进行。pthread库使用一个管理线程（__pthread_manager()，每个进程独立且唯一）来管理线程的创建和终止，为线程分配线程ID，发送线程相关的信号（比如Cancel），而主线程（pthread_create()）的调用者则通过管道将请求信息传给管理线程。 

二、线程取消 

2．1 线程取消的定义 
一般情况下，线程在其主体函数退出的时候会自动终止，但同时也可以因为接收到另一个线程发来的终止（取消）请求而强制终止。 

2．2 线程取消的语义 
线程取消的方法是向目标线程发Cancel信号，但如何处理Cancel信号则由目标线程自己决定，或者忽略、或者立即终止、或者继续运行至Cancelation-point（取消点），由不同的Cancelation状态决定。 

线程接收到CANCEL信号的缺省处理（即pthread_create()创建线程的缺省状态）是继续运行至取消点，也就是说设置一个CANCELED状态，线程继续运行，只有运行至Cancelation-point的时候才会退出。 

2．3 取消点 
根据POSIX标准，pthread_join()、pthread_testcancel()、pthread_cond_wait()、pthread_cond_timedwait()、sem_wait()、sigwait()等函数以及read()、write()等会引起阻塞的系统调用都是Cancelation-point，而其他pthread函数都不会引起Cancelation动作。但是pthread_cancel的手册页声称，由于LinuxThread库与C库结合得不好，因而目前C库函数都不是Cancelation-point；但CANCEL信号会使线程从阻塞的系统调用中退出，并置EINTR错误码，因此可以在需要作为Cancelation-point的系统调用前后调用pthread_testcancel()，从而达到POSIX标准所要求的目标，即如下代码段： 
pthread_testcancel(); 
retcode = read(fd, buffer, length); 
pthread_testcancel(); 



2．4 程序设计方面的考虑 
如果线程处于无限循环中，且循环体内没有执行至取消点的必然路径，则线程无法由外部其他线程的取消请求而终止。因此在这样的循环体的必经路径上应该加入pthread_testcancel()调用。 

2．5 与线程取消相关的pthread函数 
int pthread_cancel(pthread_t thread) 
发送终止信号给thread线程，如果成功则返回0，否则为非0值。发送成功并不意味着thread会终止。 

int pthread_setcancelstate(int state, int *oldstate) 
设置本线程对Cancel信号的反应，state有两种值：pthread_CANCEL_ENABLE（缺省）和pthread_CANCEL_DISABLE，分别表示收到信号后设为CANCLED状态和忽略CANCEL信号继续运行；old_state如果不为NULL则存入原来的Cancel状态以便恢复。 

int pthread_setcanceltype(int type, int *oldtype) 
设置本线程取消动作的执行时机，type由两种取值：pthread_CANCEL_DEFFERED和pthread_CANCEL_ASYCHRONOUS，仅当Cancel状态为Enable时有效，分别表示收到信号后继续运行至下一个取消点再退出和立即执行取消动作（退出）；oldtype如果不为NULL则存入运来的取消动作类型值。 

void pthread_testcancel(void) 
检查本线程是否处于Canceld状态，如果是，则进行取消动作，否则直接返回。


这个锁机制同时也不是异步信号安全的，也就是说，不应该在信号处理过程中使用互斥锁，否则容易造成死锁。 

二． 条件变量 
条件变量是利用线程间共享的全局变量进行同步的一种机制，主要包括两个动作：一个线程等待"条件变量的条件成立"而挂起；另一个线程使"条件成立"（给出条件成立信号）。为了防止竞争，条件变量的使用总是和一个互斥锁结合在一起。 

1． 创建和注销 
条件变量和互斥锁一样，都有静态动态两种创建方式，静态方式使用pthread_COND_INITIALIZER常量，如下： 
pthread_cond_t cond=pthread_COND_INITIALIZER 

动态方式调用pthread_cond_init()函数，API定义如下： 
int pthread_cond_init(pthread_cond_t *cond, pthread_condattr_t *cond_attr) 

尽管POSIX标准中为条件变量定义了属性，但在LinuxThreads中没有实现，因此cond_attr值通常为NULL，且被忽略。 

注销一个条件变量需要调用pthread_cond_destroy()，只有在没有线程在该条件变量上等待的时候才能注销这个条件变量，否则返回EBUSY。因为Linux实现的条件变量没有分配什么资源，所以注销动作只包括检查是否有等待线程。API定义如下： 
int pthread_cond_destroy(pthread_cond_t *cond) 

2． 等待和激发 
int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex) 
int pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime) 

等待条件有两种方式：无条件等待pthread_cond_wait()和计时等待pthread_cond_timedwait()，其中计时等待方式如果在给定时刻前条件没有满足，则返回ETIMEOUT，结束等待，其中abstime以与time()系统调用相同意义的绝对时间形式出现，0表示格林尼治时间1970年1月1日0时0分0秒。

无论哪种等待方式，都必须和一个互斥锁配合，以防止多个线程同时请求pthread_cond_wait()（或pthread_cond_timedwait()，下同）的竞争条件（Race Condition）。mutex互斥锁必须是普通锁（pthread_MUTEX_TIMED_NP）或者适应锁（pthread_MUTEX_ADAPTIVE_NP），且在调用pthread_cond_wait()前必须由本线程加锁（pthread_mutex_lock()），而在更新条件等待队列以前，mutex保持锁定状态，并在线程挂起进入等待前解锁。在条件满足从而离开pthread_cond_wait()之前，mutex将被重新加锁，以与进入pthread_cond_wait()前的加锁动作对应。 

激发条件有两种形式，pthread_cond_signal()激活一个等待该条件的线程，存在多个等待线程时按入队顺序激活其中一个；而pthread_cond_broadcast()则激活所有等待线程。 

3． 其他 
pthread_cond_wait()和pthread_cond_timedwait()都被实现为取消点，因此，在该处等待的线程将立即重新运行，在重新锁定mutex后离开pthread_cond_wait()，然后执行取消动作。也就是说如果pthread_cond_wait()被取消，mutex是保持锁定状态的，因而需要定义退出回调函数来为其解锁。 

以下示例集中演示了互斥锁和条件变量的结合使用，以及取消对于条件等待动作的影响。在例子中，有两个线程被启动，并等待同一个条件变量，如果不使用退出回调函数（见范例中的注释部分），则tid2将在pthread_mutex_lock()处永久等待。如果使用回调函数，则tid2的条件等待及主线程的条件激发都能正常工作。 


#include <stdio.h> 
#include <pthread.h> 
#include <unistd.h> 

pthread_mutex_t mutex; 
pthread_cond_t cond; 

void * child1(void *arg) 
{ 
pthread_cleanup_push(pthread_mutex_unlock,&mutex); /* comment 1 */ 
while(1){ 
printf("thread 1 get running \n"); 
printf("thread 1 pthread_mutex_lock returns %d\n", 
pthread_mutex_lock(&mutex)); 
pthread_cond_wait(&cond,&mutex); 
printf("thread 1 condition applied\n"); 


pthread_mutex_unlock(&mutex); 
sleep(5); 
} 
pthread_cleanup_pop(0); /* comment 2 */ 
} 

void *child2(void *arg) 
{ 
while(1){ 
sleep(3); /* comment 3 */ 
printf("thread 2 get running.\n"); 
printf("thread 2 pthread_mutex_lock returns %d\n", 
pthread_mutex_lock(&mutex)); 
pthread_cond_wait(&cond,&mutex); 
printf("thread 2 condition applied\n"); 
pthread_mutex_unlock(&mutex); 
sleep(1); 
} 
} 

int main(void) 
{ 
int tid1,tid2; 

printf("hello, condition variable test\n"); 
pthread_mutex_init(&mutex,NULL); 
pthread_cond_init(&cond,NULL); 
pthread_create(&tid1,NULL,child1,NULL); 
pthread_create(&tid2,NULL,child2,NULL); 
do{ 
sleep(2); /* comment 4 */ 
pthread_cancel(tid1); /* comment 5 */ 
sleep(2); /* comment 6 */ 
pthread_cond_signal(&cond); 
}while(1); 
sleep(100); 
pthread_exit(0); 
} 



如果不做注释5的pthread_cancel()动作，即使没有那些sleep()延时操作，child1和child2都能正常工作。注释3和注释4的延迟使得child1有时间完成取消动作，从而使child2能在child1退出之后进入请求锁操作。如果没有注释1和注释2的回调函数定义，系统将挂起在child2请求锁的地方；而如果同时也不做注释3和注释4的延时，child2能在child1完成取消动作以前得到控制，从而顺利执行申请锁的操作，但却可能挂起在pthread_cond_wait()中，因为其中也有申请mutex的操作。child1函数给出的是标准的条件变量的使用方式：回调函数保护，等待条件前锁定，pthread_cond_wait()返回后解锁。 

条件变量机制不是异步信号安全的，也就是说，在信号处理函数中调用pthread_cond_signal()或者pthread_cond_broadcast()很可能引起死锁。 

三． 信号灯 
信号灯与互斥锁和条件变量的主要不同在于"灯"的概念，灯亮则意味着资源可用，灯灭则意味着不可用。如果说后两中同步方式侧重于"等待"操作，即资源不可用的话，信号灯机制则侧重于点灯，即告知资源可用；没有等待线程的解锁或激发条件都是没有意义的，而没有等待灯亮的线程的点灯操作则有效，且能保持灯亮状态。当然，这样的操作原语也意味着更多的开销。 

信号灯的应用除了灯亮/灯灭这种二元灯以外，也可以采用大于1的灯数，以表示资源数大于1，这时可以称之为多元灯。 

1． 创建和注销 
POSIX信号灯标准定义了有名信号灯和无名信号灯两种，但LinuxThreads的实现仅有无名灯，同时有名灯除了总是可用于多进程之间以外，在使用上与无名灯并没有很大的区别，因此下面仅就无名灯进行讨论。 

int sem_init(sem_t *sem, int pshared, unsigned int value) 
这是创建信号灯的API，其中value为信号灯的初值，pshared表示是否为多进程共享而不仅仅是用于一个进程。LinuxThreads没有实现多进程共享信号灯，因此所有非0值的pshared输入都将使sem_init()返回-1，且置errno为ENOSYS。初始化好的信号灯由sem变量表征，用于以下点灯、灭灯操作。 

int sem_destroy(sem_t * sem) 
被注销的信号灯sem要求已没有线程在等待该信号灯，否则返回-1，且置errno为EBUSY。除此之外，LinuxThreads的信号灯注销函数不做其他动作。 

2． 点灯和灭灯 
int sem_post(sem_t * sem) 
点灯操作将信号灯值原子地加1，表示增加一个可访问的资源。 

int sem_wait(sem_t * sem) 
int sem_trywait(sem_t * sem) 
sem_wait()为等待灯亮操作，等待灯亮（信号灯值大于0），然后将信号灯原子地减1，并返回。sem_trywait()为sem_wait()的非阻塞版，如果信号灯计数大于0，则原子地减1并返回0，否则立即返回-1，errno置为EAGAIN。 

3． 获取灯值 
int sem_getvalue(sem_t * sem, int * sval) 


{ int oldtype; 
pthread_setcanceltype(pthread_CANCEL_DEFERRED, &oldtype); 
pthread_cleanup_push(routine, arg); 
... 
pthread_cleanup_pop(execute); 
pthread_setcanceltype(oldtype, NULL); 
} 



3． 线程终止的同步及其返回值 
一般情况下，进程中各个线程的运行都是相互独立的，线程的终止并不会通知，也不会影响其他线程，终止的线程所占用的资源也并不会随着线程的终止而得到释放。正如进程之间可以用wait()系统调用来同步终止并释放资源一样，线程之间也有类似机制，那就是pthread_join()函数。 


void pthread_exit(void *retval) 
int pthread_join(pthread_t th, void **thread_return) 
int pthread_detach(pthread_t th) 




pthread_join()的调用者将挂起并等待th线程终止，retval是pthread_exit()调用者线程（线程ID为th）的返回值，如果thread_return不为NULL，则*thread_return=retval。需要注意的是一个线程仅允许唯一的一个线程使用pthread_join()等待它的终止，并且被等待的线程应该处于可join状态，即非DETACHED状态。 

如果进程中的某个线程执行了pthread_detach(th)，则th线程将处于DETACHED状态，这使得th线程在结束运行时自行释放所占用的内存资源，同时也无法由pthread_join()同步，pthread_detach()执行之后，对th请求pthread_join()将返回错误。 

一个可join的线程所占用的内存仅当有线程对其执行了pthread_join()后才会释放，因此为了避免内存泄漏，所有线程的终止，要么已设为DETACHED，要么就需要使用pthread_join()来回收。 

4． 关于pthread_exit()和return 
理论上说，pthread_exit()和线程宿体函数退出的功能是相同的，函数结束时会在内部自动调用pthread_exit()来清理线程相关的资源。但实际上二者由于编译器的处理有很大的不同。 

在进程主函数（main()）中调用pthread_exit()，只会使主函数所在的线程（可以说是进程的主线程）退出；而如果是return，编译器将使其调用进程退出的代码（如_exit()），从而导致进程及其所有线程结束运行。 

其次，在线程宿主函数中主动调用return，如果return语句包含在pthread_cleanup_push()/pthread_cleanup_pop()对中，则不会引起清理函数的执行，反而会导致segment fault。

Posix线程编程指南(5)

内容： 
1．获得本线程ID 
2．判断两个线程是否为同一线程 
3．仅执行一次的操作 
4．pthread_kill_other_threads_np() 
关于作者 


相关内容： 

(1) 线程创建与取消 
(2) 线程私有数据 
(3) 线程同步 
(4) 线程终止 




杂项 
杨沙洲(pubb@163.net) 
2001 年 11 月 

这是一个关于Posix线程编程的专栏。作者在阐明概念的基础上，将向您详细讲述Posix线程库API。本文是第五篇将向您讲述pthread_self()、pthread_equal()和pthread_once()等杂项函数。 
在Posix线程规范中还有几个辅助函数难以归类，暂且称其为杂项函数，主要包括pthread_self()、pthread_equal()和pthread_once()三个，另外还有一个LinuxThreads非可移植性扩展函数pthread_kill_other_threads_np()。本文就介绍这几个函数的定义和使用。 

1． 获得本线程ID 


pthread_t pthread_self(void) 

本函数返回本线程的标识符。 

在LinuxThreads中，每个线程都用一个pthread_descr结构来描述，其中包含了线程状态、线程ID等所有需要的数据结构，此函数的实现就是在线程栈帧中找到本线程的pthread_descr结构，然后返回其中的p_tid项。 

pthread_t类型在LinuxThreads中定义为无符号长整型。 

2． 判断两个线程是否为同一线程 
int pthread_equal(pthread_t thread1, pthread_t thread2) 

判断两个线程描述符是否指向同一线程。在LinuxThreads中，线程ID相同的线程必然是同一个线程，因此，这个函数的实现仅仅判断thread1和thread2是否相等。 

3． 仅执行一次的操作 
int pthread_once(pthread_once_t *once_control, void (*init_routine) (void)) 

本函数使用初值为pthread_ONCE_INIT的once_control变量保证init_routine()函数在本进程执行序列中仅执行一次。 
#include <stdio.h> 
#include <pthread.h> 

pthread_once_t once=pthread_ONCE_INIT; 

void once_run(void) 
{ 
printf("once_run in thread %d\n",pthread_self()); 
} 

void * child1(void *arg) 
{ 
int tid=pthread_self(); 
printf("thread %d enter\n",tid); 
pthread_once(&once,once_run); 
printf("thread %d returns\n",tid); 
} 

void * child2(void *arg) 
{ 
int tid=pthread_self(); 
printf("thread %d enter\n",tid); 
pthread_once(&once,once_run); 
printf("thread %d returns\n",tid); 
} 

int main(void) 
{ 
int tid1,tid2; 

printf("hello\n"); 
pthread_create(&tid1,NULL,child1,NULL); 
pthread_create(&tid2,NULL,child2,NULL); 
sleep(10); 
printf("main thread exit\n"); 
return 0; 
} 



once_run()函数仅执行一次，且究竟在哪个线程中执行是不定的，尽管pthread_once(&once,once_run)出现在两个线程中。 

LinuxThreads使用互斥锁和条件变量保证由pthread_once()指定的函数执行且仅执行一次，而once_control则表征是否执行过。如果once_control的初值不是pthread_ONCE_INIT（LinuxThreads定义为0），pthread_once()的行为就会不正常。在LinuxThreads中，实际"一次性函数"的执行状态有三种：NEVER（0）、IN_PROGRESS（1）、DONE（2），如果once初值设为1，则由于所有pthread_once()都必须等待其中一个激发"已执行一次"信号，因此所有pthread_once()都会陷入永久的等待中；如果设为2，则表示该函数已执行过一次，从而所有pthread_once()都会立即返回0。 

4． pthread_kill_other_threads_np() 
void pthread_kill_other_threads_np(void) 

这个函数是LinuxThreads针对本身无法实现的POSIX约定而做的扩展。POSIX要求当进程的某一个线程执行exec*系统调用在进程空间中加载另一个程序时，当前进程的所有线程都应终止。由于LinuxThreads的局限性，该机制无法在exec中实现，因此要求线程执行exec前手工终止其他所有线程。pthread_kill_other_threads_np()的作用就是这个。 

需要注意的是，pthread_kill_other_threads_np()并没有通过pthread_cancel()来终止线程，而是直接向管理线程发"进程退出"信号，使所有其他线程都结束运行，而不经过Cancel动作，当然也不会执行退出回调函数。尽管LinuxThreads的实验结果与文档说明相同，但代码实现中却是用的__pthread_sig_cancel信号来kill线程，应该效果与执行pthread_cancel()是一样的，其中原因目前还不清楚。

转载