linux线程学习
来源：互联网 发布：什么翻译软件好 编辑：程序博客网 时间：2024/05/20 10:51
1、线程创建
2、线程终止
3、线程同步
4、私有数据
5、线程同步
6、出错处理
gcc –o
createthread –lpthread createthread.c
1、线程创建
#include
int pthread_create(pthread_t *thread,pthread_attr_t
*attr,
void *(*start_routine)(void *),void
*arg);
thread：所创建的线程号。
attr：所创建的线程属性，这个将在后面详细说明。
start_routine：即将运行的线程函数。
arg：传递给线程函数的参数。
void*
print_xs (void* unused);
pthread_create (&thread_id, NULL, &print_xs,
NULL);
pthread_create (&thread_id, NULL, (void *)print_xs,
NULL);
void pthread_exit(void *retval);
终止当前进程
int
pthread_join(pthread *thread,void
**thread_return);
thread：等待退出线程的线程号。
thread_return：退出线程的返回值。
如果你的主线程，也就是main函数执行的那个线程，在你其他县城推出之前就已经退出，那么带来的bug则不可估量。通过pthread_join函数会让主线程阻塞，直到所有线程都已经退出。
pthread_create
(&thread1_id, NULL, &char_print, &thread1_args);
pthread_create
(&thread2_id, NULL, &char_print, &thread2_args);
pthread_join
(thread1_id, NULL);
pthread_join (thread2_id, NULL);
pthread_t
pthread_self(void)
获取本线程的线程ID
int pthread_equal(pthread_t
thread1,pthread_t thread2)
判断两个线程ID是否指向同一个线程
int
pthread_once(pthread_once_t
*once_control,void(*int_routine)(void))
用来保证init_routine线程函数在进程中仅执行一次
pthread_cleanup_push()
pthread_cleanup_pop()
在这两个函数中的终止动作（如pthread_exit）都将执行pthread_cleanup_pop()指定的清理函数
#include
void pthread_detach(pthread_t
th);
使th处于DETACHED状态
私有数据
在多线程环境下，进程内的所有线程共享进程的数据空间，因此全局变量为所有线程共享，在程序设计中有时候需要保存
线程自己的全局变量，这种特殊的变量仅在某个线程内部有效
线程私有数据采用了一种被称为一键多值的技术，即一个键对应多个值。访问数据时都是通过键值来访问，好像是对一个键值访问
操作线程私有数据的函数
#include
int pthread_key_create(pthread_key_t *key,void
(*destr_function) (void*));
int pthread_setspecific(pthread_key_t key,const
void *pointer);
void * pthread_getspecific(pthread_key_t key);
int
phread_key_delete(pthread_key_t key);
线程同步-互斥锁
int
pthread_mutex_init(pthread_mutex_t *mutex,const pthread_mutexattr_t
*mutexattr);
pthread_mutex_t mutex =
PTHREAD_MUTEX_INITIALIZER;
初始化一个互斥锁
int
pthread_mutex_destroy(pthread_mutex_t *mutex);
注销一个互斥锁
int
pthread_mutex_lock(pthread_mutex_t *mutex);
加锁，如果不成功，阻塞等待
int
pthread_mutex_unlock(pthread_mutex_t *mutex);
解锁
int
pthread_mutex_trylock(pthread_mutex_t
*mutex);
测试加锁，如果不成功立即返回错误码为EBUSY
互斥锁的属性及意义
PTHREAD_MUTEX_TIMED_NP
普通锁：当一个线程加锁后，其余请求所的线程形成等待队列，解锁后按优先级获得锁
PTHREAD_MUTEX_RECURSIVE_NP
嵌套锁：允许一个线程对同一个锁多次加锁，并通过多次unlock解锁，如果不是同线程请求，则在解锁是重新竞争
PTHREAD_MUTEX_ERRORCHECK_NP
检错锁：解锁后重新竞争
PTHREAD_MUTEX_ADEPTIVE_NP
线程同步-条件变量
条件变量分为两部分:
条件和变量. 条件本身是由互斥量保护的. 线程在改变条件状态前先要锁住互斥量.
1. 初始化:
条件变量采用的数据类型是pthread_cond_t, 在使用之前必须要进行初始化, 这包括两种方式:
* 静态:
可以把常量PTHREAD_COND_INITIALIZER给静态分配的条件变量.
* 动态:
pthread_cond_init函数, 是释放动态条件变量的内存空间之前, 要用pthread_cond_destroy对其进行清理.
#include
int pthread_cond_init(pthread_cond_t *cond,
pthread_condattr_t *cond_attr);
int pthread_cond_destroy(pthread_cond_t
*cond);
成功则返回0, 出错则返回错误编号.
当pthread_cond_init的attr参数为NULL时,
会创建一个默认属性的条件变量; 非默认情况以后讨论.
2. 等待条件:
#include
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 *timeout);
成功则返回0,
出错则返回错误编号.
这两个函数分别是阻塞等待和超时等待.
等待条件函数等待条件变为真,
传递给pthread_cond_wait的互斥量对条件进行保护, 调用者把锁住的互斥量传递给函数. 函数把调用线程放到等待条件的线程列表上, 然后对互斥量解锁,
这两个操作是原子的. 这样便关闭了条件检查和线程进入休眠状态等待条件改变这两个操作之间的时间通道,
这样线程就不会错过条件的任何变化.
当pthread_cond_wait返回时, 互斥量再次被锁住.
3.
通知条件:
#include
int pthread_cond_signal(pthread_cond_t
*cond);
int pthread_cond_broadcast(pthread_cond_t *cond);
成功则返回0,
出错则返回错误编号.
这两个函数用于通知线程条件已经满足. 调用这两个函数, 也称向线程或条件发送信号. 必须注意,
一定要在改变条件状态以后再给线程发送信号.
文档选项
将此页作为电子邮件发送
将此页作为电子邮件发送
级别： 初级
杨沙洲 (pubb@163.net)
XML error:
Please enter a value for the author element's jobtitle attribute, or the
company-name element, or both.
2001 年 10 月 01
日
这是一个关于Posix线程编程的专栏。作者在阐明概念的基础上，将向您详细讲述Posix线程库API。本文是第三篇将向您讲述线程同步。
互斥锁
尽管在Posix
Thread中同样可以使用IPC的信号量机制来实现互斥锁mutex功能，但显然semphore的功能过于强大了，在Posix
Thread中定义了另外一套专门用于线程同步的mutex函数。
1．
创建和销毁
有两种方法创建互斥锁，静态方式和动态方式。POSIX定义了一个宏PTHREAD_MUTEX_INITIALIZER来静态初始化互斥锁，方法如下：
pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;
在LinuxThreads实现中，pthread_mutex_t是一个结构，而PTHREAD_MUTEX_INITIALIZER则是一个结构常量。
动态方式是采用pthread_mutex_init()函数来初始化互斥锁，API定义如下：
int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t
*mutexattr)
其中mutexattr用于指定互斥锁属性（见下），如果为NULL则使用缺省属性。
pthread_mutex_destroy()用于注销一个互斥锁，API定义如下：
int pthread_mutex_destroy(pthread_mutex_t *mutex)
销毁一个互斥锁即意味着释放它所占用的资源，且要求锁当前处于开放状态。由于在Linux中，互斥锁并不占用任何资源，因此LinuxThreads中的pthread_mutex_destroy()除了检查锁状态以外（锁定状态则返回EBUSY）没有其他动作。
2．
互斥锁属性
互斥锁的属性在创建锁的时候指定，在LinuxThreads实现中仅有一个锁类型属性，不同的锁类型在试图对一个已经被锁定的互斥锁加锁时表现不同。当前（glibc2.2.3,linuxthreads0.9）有四个值可供选择：
*
PTHREAD_MUTEX_TIMED_NP，这是缺省值，也就是普通锁。当一个线程加锁以后，其余请求锁的线程将形成一个等待队列，并在解锁后按优先级获得锁。这种锁策略保证了资源分配的公平性。
*
PTHREAD_MUTEX_RECURSIVE_NP，嵌套锁，允许同一个线程对同一个锁成功获得多次，并通过多次unlock解锁。如果是不同线程请求，则在加锁线程解锁时重新竞争。
*
PTHREAD_MUTEX_ERRORCHECK_NP，检错锁，如果同一个线程请求同一个锁，则返回EDEADLK，否则与PTHREAD_MUTEX_TIMED_NP类型动作相同。这样就保证当不允许多次加锁时不会出现最简单情况下的死锁。
* PTHREAD_MUTEX_ADAPTIVE_NP，适应锁，动作最简单的锁类型，仅等待解锁后重新竞争。
3．
锁操作
锁
操作主要包括加锁pthread_mutex_lock()、解锁pthread_mutex_unlock()和测试加锁
pthread_mutex_trylock()三个，不论哪种类型的锁，都不可能被两个不同的线程同时得到，而必须等待解锁。对于普通锁和适应锁类型，
解锁者可以是同进程内任何线程；而检错锁则必须由加锁者解锁才有效，否则返回EPERM；对于嵌套锁，文档和实现要求必须由加锁者解锁，但实验结果表明并
没有这种限制，这个不同目前还没有得到解释。在同一进程中的线程，如果加锁后没有解锁，则任何其他线程都无法再获得锁。
int
pthread_mutex_lock(pthread_mutex_t *mutex)
int
pthread_mutex_unlock(pthread_mutex_t *mutex)
int
pthread_mutex_trylock(pthread_mutex_t
*mutex)
pthread_mutex_trylock()语义与pthread_mutex_lock()类似，不同的是在锁已经被占据时返回EBUSY而不是挂起等待。
4．
其他
POSIX
线程锁机制的Linux实现都不是取消点，因此，延迟取消类型的线程不会因收到取消信号而离开加锁等待。值得注意的是，如果线程在加锁后解锁前被取消，锁将永远保持锁定状态，因此如果在关键区段内有取消点存在，或者设置了异步取消类型，则必须在退出回调函数中解锁。
这个锁机制同时也不是异步信号安全的，也就是说，不应该在信号处理过程中使用互斥锁，否则容易造成死锁。
互斥锁
尽管在Posix
Thread中同样可以使用IPC的信号量机制来实现互斥锁mutex功能，但显然semphore的功能过于强大了，在Posix
Thread中定义了另外一套专门用于线程同步的mutex函数。
1．
创建和销毁
有两种方法创建互斥锁，静态方式和动态方式。POSIX定义了一个宏PTHREAD_MUTEX_INITIALIZER来静态初始化互斥锁，方法如下：
pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;
在LinuxThreads实现中，pthread_mutex_t是一个结构，而PTHREAD_MUTEX_INITIALIZER则是一个结构常量。
动态方式是采用pthread_mutex_init()函数来初始化互斥锁，API定义如下：
int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t
*mutexattr)
其中mutexattr用于指定互斥锁属性（见下），如果为NULL则使用缺省属性。
pthread_mutex_destroy()用于注销一个互斥锁，API定义如下：
int pthread_mutex_destroy(pthread_mutex_t *mutex)
销毁一个互斥锁即意味着释放它所占用的资源，且要求锁当前处于开放状态。由于在Linux中，互斥锁并不占用任何资源，因此LinuxThreads中的pthread_mutex_destroy()除了检查锁状态以外（锁定状态则返回EBUSY）没有其他动作。
2．
互斥锁属性
互斥锁的属性在创建锁的时候指定，在LinuxThreads实现中仅有一个锁类型属性，不同的锁类型在试图对一个已经被锁定的互斥锁加锁时表现不同。当前（glibc2.2.3,linuxthreads0.9）有四个值可供选择：
*
PTHREAD_MUTEX_TIMED_NP，这是缺省值，也就是普通锁。当一个线程加锁以后，其余请求锁的线程将形成一个等待队列，并在解锁后按优先级获得锁。这种锁策略保证了资源分配的公平性。
*
PTHREAD_MUTEX_RECURSIVE_NP，嵌套锁，允许同一个线程对同一个锁成功获得多次，并通过多次unlock解锁。如果是不同线程请求，则在加锁线程解锁时重新竞争。
*
PTHREAD_MUTEX_ERRORCHECK_NP，检错锁，如果同一个线程请求同一个锁，则返回EDEADLK，否则与PTHREAD_MUTEX_TIMED_NP类型动作相同。这样就保证当不允许多次加锁时不会出现最简单情况下的死锁。
* PTHREAD_MUTEX_ADAPTIVE_NP，适应锁，动作最简单的锁类型，仅等待解锁后重新竞争。
3．
锁操作
锁
操作主要包括加锁pthread_mutex_lock()、解锁pthread_mutex_unlock()和测试加锁
pthread_mutex_trylock()三个，不论哪种类型的锁，都不可能被两个不同的线程同时得到，而必须等待解锁。对于普通锁和适应锁类型，
解锁者可以是同进程内任何线程；而检错锁则必须由加锁者解锁才有效，否则返回EPERM；对于嵌套锁，文档和实现要求必须由加锁者解锁，但实验结果表明并
没有这种限制，这个不同目前还没有得到解释。在同一进程中的线程，如果加锁后没有解锁，则任何其他线程都无法再获得锁。
int
pthread_mutex_lock(pthread_mutex_t *mutex)
int
pthread_mutex_unlock(pthread_mutex_t *mutex)
int
pthread_mutex_trylock(pthread_mutex_t
*mutex)
pthread_mutex_trylock()语义与pthread_mutex_lock()类似，不同的是在锁已经被占据时返回EBUSY而不是挂起等待。
4．
其他
POSIX
线程锁机制的Linux实现都不是取消点，因此，延迟取消类型的线程不会因收到取消信号而离开加锁等待。值得注意的是，如果线程在加锁后解锁前被取消，锁将永远保持锁定状态，因此如果在关键区段内有取消点存在，或者设置了异步取消类型，则必须在退出回调函数中解锁。
这个锁机制同时也不是异步信号安全的，也就是说，不应该在信号处理过程中使用互斥锁，否则容易造成死锁。
-----------------------------------------------------------------------------------
条件变量是利用线程间共享的全局变量进行同步的一种机制，主要包括两个动作：一个线程等待"条件变量的条件成立"而挂起；另一个线程使"条件成立"（给出条件成立信号）。为了防止竞争，条件变量的使用总是和一个互斥锁结合在一起。
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
#include
#include
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)
读取sem中的灯计数，存于*sval中，并返回0。
4．
其他
sem_wait()被实现为取消点，而且在支持原子"比较且交换"指令的体系结构上，sem_post()是唯一能用于异步信号处理函数的POSIX异步信号安全的API。
异步信号
由
于LinuxThreads是在核外使用核内轻量级进程实现的线程，所以基于内核的异步信号操作对于线程也是有效的。但同时，由于异步信号总是实际发往某
个进程，所以无法实现POSIX标准所要求的"信号到达某个进程，然后再由该进程将信号分发到所有没有阻塞该信号的线程中"原语，而是只能影响到其中一个
线程。
POSIX异步信号同时也是一个标准C库提供的功能，主要包括信号集管理（sigemptyset()、
sigfillset()、
sigaddset()、sigdelset()、sigismember()等）、信号处理函数安装（sigaction()）、信号阻塞控制
（sigprocmask()）、被阻塞信号查询（sigpending()）、信号等待(sigsuspend())等，它们与发送信号的kill()
等函数配合就能实现进程间异步信号功能。LinuxThreads围绕线程封装了sigaction()何raise()，本节集中讨论
LinuxThreads中扩展的异步信号函数，包括pthread_sigmask()、pthread_kill()和sigwait()三个函数。
毫无疑问，所有POSIX异步信号函数对于线程都是可用的。
int
pthread_sigmask(int how, const sigset_t *newmask, sigset_t
*oldmask)
设置线程的信号屏蔽码，语义与sigprocmask()相同，但对不允许屏蔽的Cancel信号和不允许响应的Restart信号进行了保护。被屏蔽的信号保存在信号队列中，可由sigpending()函数取出。
int
pthread_kill(pthread_t thread, int
signo)
向thread号线程发送signo信号。实现中在通过thread线程号定位到对应进程号以后使用kill()系统调用完成发送。
int
sigwait(const sigset_t *set, int
*sig)
挂
起线程，等待set中指定的信号之一到达，并将到达的信号存入*sig中。POSIX标准建议在调用sigwait()等待信号以前，进程中所有线程都应
屏蔽该信号，以保证仅有sigwait()的调用者获得该信号，因此，对于需要等待同步的异步信号，总是应该在创建任何线程以前调用
pthread_sigmask()屏蔽该信号的处理。而且，调用sigwait()期间，原来附接在该信号上的信号处理函数不会被调用。
如果在等待期间接收到Cancel信号，则立即退出等待，也就是说sigwait()被实现为取消点。
其他同步方式
除了上述讨论的同步方式以外，其他很多进程间通信手段对于LinuxThreads也是可用的，比如基于文件系统的IPC（管道、Unix域Socket等）、消息队列（Sys.V或者Posix的）、System
V的信号灯等。只有一点需要注意，LinuxThreads在核内是作为共享存储区、共享文件系统属性、共享信号处理、共享文件描述符的独立进程看待的。
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;
线程的分离状态
线程的分离状态决定一个线程以什么样的方式来终止自己。在默认情况下线程是非分离状态的，这种情况下，原有的线程等待创建的线程结束。只有当pthread_join（）函数返回时，创建的线程才算终止，才能释放自己占用的系统资源。
而
分离线程不是这样子的，它没有被其他的线程所等待，自己运行结束了，线程也就终止了，马上释放系统资源。程序员应该根据自己的需要，选择适当的分离状态。
所以如果我们在创建线程时就知道不需要了解线程的终止状态，则可以pthread_attr_t结构中的detachstate线程属性，让线程以分离状
态启动。
功能：
获取/修改线程的分离状态属性
头文件：
#include
函数原形：
int
pthread_attr_getdetachstate(const pthread_attr_t * attr,int
*detachstate);
int pthread_attr_setdetachstate(pthread_attr_t *attr,int
detachstate);
参数：
Attr 线程属性变量
Detachstate
线程的分离状态属性
返回值：
若成功返回0，若失败返回-1。
可
以使用pthread_attr_setdetachstate函数把线程属性detachstate设置为下面的两个合法值之一：设置为
PTHREAD_CREATE_DETACHED,以分离状态启动线程；或者设置为PTHREAD_CREATE_JOINABLE,正常启动线程。可以
使用pthread_attr_getdetachstate函数获取当前的datachstate线程属性。
以分离状态创建线程
#iinclude
void *child_thread(void *arg)
{
printf(“child thread
run!\n”);
}
int main(int argc,char *argv[
])
{
pthread_t
tid;
pthread_attr_t
attr;
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_DETACHED);
pthread_create(&tid,&attr,fn,arg);
pthread_attr_destroy(&attr);
sleep(1);
}
线程的继承性
函数pthread_attr_setinheritsched和pthread_attr_getinheritsched分别用来设置和得到线程的继承性，这两个函数的定义如下：
功能：
获得/设置线程的继承性
头文件：
#include
函数原形：
int pthread_attr_getinheritsched(const
pthread_attr_t *attr,int *inheritsched);
int
pthread_attr_setinheritsched(pthread_attr_t *attr,int
inheritsched);
参数：
attr
线程属性变量
inheritsched
线程的继承性
返回值：
若成功返回0，若失败返回-1。
这
两个函数具有两个参数，第1个是指向属性对象的指针，第2个是继承性或指向继承性的指针。继承性决定调度的参数是从创建的进程中继承还是使用在
schedpolicy和schedparam属性中显式设置的调度信息。Pthreads不为inheritsched指定默认值，因此如果你关心线程
的调度策略和参数，必须先设置该属性。
继承性的可能值是PTHREAD_INHERIT_SCHED（表示新现成将继承创建线程的调度策略和参数）和PTHREAD_EXPLICIT_SCHED（表示使用在schedpolicy和schedparam属性中显式设置的调度策略和参数）。
如果你需要显式的设置一个线程的调度策略或参数，那么你必须在设置之前将inheritsched属性设置为PTHREAD_EXPLICIT_SCHED.
2、线程终止
3、线程同步
4、私有数据
5、线程同步
6、出错处理
gcc –o
createthread –lpthread createthread.c
1、线程创建
#include
int pthread_create(pthread_t *thread,pthread_attr_t
*attr,
void *(*start_routine)(void *),void
*arg);
thread：所创建的线程号。
attr：所创建的线程属性，这个将在后面详细说明。
start_routine：即将运行的线程函数。
arg：传递给线程函数的参数。
void*
print_xs (void* unused);
pthread_create (&thread_id, NULL, &print_xs,
NULL);
pthread_create (&thread_id, NULL, (void *)print_xs,
NULL);
void pthread_exit(void *retval);
终止当前进程
int
pthread_join(pthread *thread,void
**thread_return);
thread：等待退出线程的线程号。
thread_return：退出线程的返回值。
如果你的主线程，也就是main函数执行的那个线程，在你其他县城推出之前就已经退出，那么带来的bug则不可估量。通过pthread_join函数会让主线程阻塞，直到所有线程都已经退出。
pthread_create
(&thread1_id, NULL, &char_print, &thread1_args);
pthread_create
(&thread2_id, NULL, &char_print, &thread2_args);
pthread_join
(thread1_id, NULL);
pthread_join (thread2_id, NULL);
pthread_t
pthread_self(void)
获取本线程的线程ID
int pthread_equal(pthread_t
thread1,pthread_t thread2)
判断两个线程ID是否指向同一个线程
int
pthread_once(pthread_once_t
*once_control,void(*int_routine)(void))
用来保证init_routine线程函数在进程中仅执行一次
pthread_cleanup_push()
pthread_cleanup_pop()
在这两个函数中的终止动作（如pthread_exit）都将执行pthread_cleanup_pop()指定的清理函数
#include
void pthread_detach(pthread_t
th);
使th处于DETACHED状态
私有数据
在多线程环境下，进程内的所有线程共享进程的数据空间，因此全局变量为所有线程共享，在程序设计中有时候需要保存
线程自己的全局变量，这种特殊的变量仅在某个线程内部有效
线程私有数据采用了一种被称为一键多值的技术，即一个键对应多个值。访问数据时都是通过键值来访问，好像是对一个键值访问
操作线程私有数据的函数
#include
int pthread_key_create(pthread_key_t *key,void
(*destr_function) (void*));
int pthread_setspecific(pthread_key_t key,const
void *pointer);
void * pthread_getspecific(pthread_key_t key);
int
phread_key_delete(pthread_key_t key);
线程同步-互斥锁
int
pthread_mutex_init(pthread_mutex_t *mutex,const pthread_mutexattr_t
*mutexattr);
pthread_mutex_t mutex =
PTHREAD_MUTEX_INITIALIZER;
初始化一个互斥锁
int
pthread_mutex_destroy(pthread_mutex_t *mutex);
注销一个互斥锁
int
pthread_mutex_lock(pthread_mutex_t *mutex);
加锁，如果不成功，阻塞等待
int
pthread_mutex_unlock(pthread_mutex_t *mutex);
解锁
int
pthread_mutex_trylock(pthread_mutex_t
*mutex);
测试加锁，如果不成功立即返回错误码为EBUSY
互斥锁的属性及意义
PTHREAD_MUTEX_TIMED_NP
普通锁：当一个线程加锁后，其余请求所的线程形成等待队列，解锁后按优先级获得锁
PTHREAD_MUTEX_RECURSIVE_NP
嵌套锁：允许一个线程对同一个锁多次加锁，并通过多次unlock解锁，如果不是同线程请求，则在解锁是重新竞争
PTHREAD_MUTEX_ERRORCHECK_NP
检错锁：解锁后重新竞争
PTHREAD_MUTEX_ADEPTIVE_NP
线程同步-条件变量
条件变量分为两部分:
条件和变量. 条件本身是由互斥量保护的. 线程在改变条件状态前先要锁住互斥量.
1. 初始化:
条件变量采用的数据类型是pthread_cond_t, 在使用之前必须要进行初始化, 这包括两种方式:
* 静态:
可以把常量PTHREAD_COND_INITIALIZER给静态分配的条件变量.
* 动态:
pthread_cond_init函数, 是释放动态条件变量的内存空间之前, 要用pthread_cond_destroy对其进行清理.
#include
int pthread_cond_init(pthread_cond_t *cond,
pthread_condattr_t *cond_attr);
int pthread_cond_destroy(pthread_cond_t
*cond);
成功则返回0, 出错则返回错误编号.
当pthread_cond_init的attr参数为NULL时,
会创建一个默认属性的条件变量; 非默认情况以后讨论.
2. 等待条件:
#include
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 *timeout);
成功则返回0,
出错则返回错误编号.
这两个函数分别是阻塞等待和超时等待.
等待条件函数等待条件变为真,
传递给pthread_cond_wait的互斥量对条件进行保护, 调用者把锁住的互斥量传递给函数. 函数把调用线程放到等待条件的线程列表上, 然后对互斥量解锁,
这两个操作是原子的. 这样便关闭了条件检查和线程进入休眠状态等待条件改变这两个操作之间的时间通道,
这样线程就不会错过条件的任何变化.
当pthread_cond_wait返回时, 互斥量再次被锁住.
3.
通知条件:
#include
int pthread_cond_signal(pthread_cond_t
*cond);
int pthread_cond_broadcast(pthread_cond_t *cond);
成功则返回0,
出错则返回错误编号.
这两个函数用于通知线程条件已经满足. 调用这两个函数, 也称向线程或条件发送信号. 必须注意,
一定要在改变条件状态以后再给线程发送信号.
文档选项
将此页作为电子邮件发送
将此页作为电子邮件发送
级别： 初级
杨沙洲 (pubb@163.net)
XML error:
Please enter a value for the author element's jobtitle attribute, or the
company-name element, or both.
2001 年 10 月 01
日
这是一个关于Posix线程编程的专栏。作者在阐明概念的基础上，将向您详细讲述Posix线程库API。本文是第三篇将向您讲述线程同步。
互斥锁
尽管在Posix
Thread中同样可以使用IPC的信号量机制来实现互斥锁mutex功能，但显然semphore的功能过于强大了，在Posix
Thread中定义了另外一套专门用于线程同步的mutex函数。
1．
创建和销毁
有两种方法创建互斥锁，静态方式和动态方式。POSIX定义了一个宏PTHREAD_MUTEX_INITIALIZER来静态初始化互斥锁，方法如下：
pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;
在LinuxThreads实现中，pthread_mutex_t是一个结构，而PTHREAD_MUTEX_INITIALIZER则是一个结构常量。
动态方式是采用pthread_mutex_init()函数来初始化互斥锁，API定义如下：
int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t
*mutexattr)
其中mutexattr用于指定互斥锁属性（见下），如果为NULL则使用缺省属性。
pthread_mutex_destroy()用于注销一个互斥锁，API定义如下：
int pthread_mutex_destroy(pthread_mutex_t *mutex)
销毁一个互斥锁即意味着释放它所占用的资源，且要求锁当前处于开放状态。由于在Linux中，互斥锁并不占用任何资源，因此LinuxThreads中的pthread_mutex_destroy()除了检查锁状态以外（锁定状态则返回EBUSY）没有其他动作。
2．
互斥锁属性
互斥锁的属性在创建锁的时候指定，在LinuxThreads实现中仅有一个锁类型属性，不同的锁类型在试图对一个已经被锁定的互斥锁加锁时表现不同。当前（glibc2.2.3,linuxthreads0.9）有四个值可供选择：
*
PTHREAD_MUTEX_TIMED_NP，这是缺省值，也就是普通锁。当一个线程加锁以后，其余请求锁的线程将形成一个等待队列，并在解锁后按优先级获得锁。这种锁策略保证了资源分配的公平性。
*
PTHREAD_MUTEX_RECURSIVE_NP，嵌套锁，允许同一个线程对同一个锁成功获得多次，并通过多次unlock解锁。如果是不同线程请求，则在加锁线程解锁时重新竞争。
*
PTHREAD_MUTEX_ERRORCHECK_NP，检错锁，如果同一个线程请求同一个锁，则返回EDEADLK，否则与PTHREAD_MUTEX_TIMED_NP类型动作相同。这样就保证当不允许多次加锁时不会出现最简单情况下的死锁。
* PTHREAD_MUTEX_ADAPTIVE_NP，适应锁，动作最简单的锁类型，仅等待解锁后重新竞争。
3．
锁操作
锁
操作主要包括加锁pthread_mutex_lock()、解锁pthread_mutex_unlock()和测试加锁
pthread_mutex_trylock()三个，不论哪种类型的锁，都不可能被两个不同的线程同时得到，而必须等待解锁。对于普通锁和适应锁类型，
解锁者可以是同进程内任何线程；而检错锁则必须由加锁者解锁才有效，否则返回EPERM；对于嵌套锁，文档和实现要求必须由加锁者解锁，但实验结果表明并
没有这种限制，这个不同目前还没有得到解释。在同一进程中的线程，如果加锁后没有解锁，则任何其他线程都无法再获得锁。
int
pthread_mutex_lock(pthread_mutex_t *mutex)
int
pthread_mutex_unlock(pthread_mutex_t *mutex)
int
pthread_mutex_trylock(pthread_mutex_t
*mutex)
pthread_mutex_trylock()语义与pthread_mutex_lock()类似，不同的是在锁已经被占据时返回EBUSY而不是挂起等待。
4．
其他
POSIX
线程锁机制的Linux实现都不是取消点，因此，延迟取消类型的线程不会因收到取消信号而离开加锁等待。值得注意的是，如果线程在加锁后解锁前被取消，锁将永远保持锁定状态，因此如果在关键区段内有取消点存在，或者设置了异步取消类型，则必须在退出回调函数中解锁。
这个锁机制同时也不是异步信号安全的，也就是说，不应该在信号处理过程中使用互斥锁，否则容易造成死锁。
互斥锁
尽管在Posix
Thread中同样可以使用IPC的信号量机制来实现互斥锁mutex功能，但显然semphore的功能过于强大了，在Posix
Thread中定义了另外一套专门用于线程同步的mutex函数。
1．
创建和销毁
有两种方法创建互斥锁，静态方式和动态方式。POSIX定义了一个宏PTHREAD_MUTEX_INITIALIZER来静态初始化互斥锁，方法如下：
pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;
在LinuxThreads实现中，pthread_mutex_t是一个结构，而PTHREAD_MUTEX_INITIALIZER则是一个结构常量。
动态方式是采用pthread_mutex_init()函数来初始化互斥锁，API定义如下：
int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t
*mutexattr)
其中mutexattr用于指定互斥锁属性（见下），如果为NULL则使用缺省属性。
pthread_mutex_destroy()用于注销一个互斥锁，API定义如下：
int pthread_mutex_destroy(pthread_mutex_t *mutex)
销毁一个互斥锁即意味着释放它所占用的资源，且要求锁当前处于开放状态。由于在Linux中，互斥锁并不占用任何资源，因此LinuxThreads中的pthread_mutex_destroy()除了检查锁状态以外（锁定状态则返回EBUSY）没有其他动作。
2．
互斥锁属性
互斥锁的属性在创建锁的时候指定，在LinuxThreads实现中仅有一个锁类型属性，不同的锁类型在试图对一个已经被锁定的互斥锁加锁时表现不同。当前（glibc2.2.3,linuxthreads0.9）有四个值可供选择：
*
PTHREAD_MUTEX_TIMED_NP，这是缺省值，也就是普通锁。当一个线程加锁以后，其余请求锁的线程将形成一个等待队列，并在解锁后按优先级获得锁。这种锁策略保证了资源分配的公平性。
*
PTHREAD_MUTEX_RECURSIVE_NP，嵌套锁，允许同一个线程对同一个锁成功获得多次，并通过多次unlock解锁。如果是不同线程请求，则在加锁线程解锁时重新竞争。
*
PTHREAD_MUTEX_ERRORCHECK_NP，检错锁，如果同一个线程请求同一个锁，则返回EDEADLK，否则与PTHREAD_MUTEX_TIMED_NP类型动作相同。这样就保证当不允许多次加锁时不会出现最简单情况下的死锁。
* PTHREAD_MUTEX_ADAPTIVE_NP，适应锁，动作最简单的锁类型，仅等待解锁后重新竞争。
3．
锁操作
锁
操作主要包括加锁pthread_mutex_lock()、解锁pthread_mutex_unlock()和测试加锁
pthread_mutex_trylock()三个，不论哪种类型的锁，都不可能被两个不同的线程同时得到，而必须等待解锁。对于普通锁和适应锁类型，
解锁者可以是同进程内任何线程；而检错锁则必须由加锁者解锁才有效，否则返回EPERM；对于嵌套锁，文档和实现要求必须由加锁者解锁，但实验结果表明并
没有这种限制，这个不同目前还没有得到解释。在同一进程中的线程，如果加锁后没有解锁，则任何其他线程都无法再获得锁。
int
pthread_mutex_lock(pthread_mutex_t *mutex)
int
pthread_mutex_unlock(pthread_mutex_t *mutex)
int
pthread_mutex_trylock(pthread_mutex_t
*mutex)
pthread_mutex_trylock()语义与pthread_mutex_lock()类似，不同的是在锁已经被占据时返回EBUSY而不是挂起等待。
4．
其他
POSIX
线程锁机制的Linux实现都不是取消点，因此，延迟取消类型的线程不会因收到取消信号而离开加锁等待。值得注意的是，如果线程在加锁后解锁前被取消，锁将永远保持锁定状态，因此如果在关键区段内有取消点存在，或者设置了异步取消类型，则必须在退出回调函数中解锁。
这个锁机制同时也不是异步信号安全的，也就是说，不应该在信号处理过程中使用互斥锁，否则容易造成死锁。
-----------------------------------------------------------------------------------
条件变量是利用线程间共享的全局变量进行同步的一种机制，主要包括两个动作：一个线程等待"条件变量的条件成立"而挂起；另一个线程使"条件成立"（给出条件成立信号）。为了防止竞争，条件变量的使用总是和一个互斥锁结合在一起。
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
#include
#include
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)
读取sem中的灯计数，存于*sval中，并返回0。
4．
其他
sem_wait()被实现为取消点，而且在支持原子"比较且交换"指令的体系结构上，sem_post()是唯一能用于异步信号处理函数的POSIX异步信号安全的API。
异步信号
由
于LinuxThreads是在核外使用核内轻量级进程实现的线程，所以基于内核的异步信号操作对于线程也是有效的。但同时，由于异步信号总是实际发往某
个进程，所以无法实现POSIX标准所要求的"信号到达某个进程，然后再由该进程将信号分发到所有没有阻塞该信号的线程中"原语，而是只能影响到其中一个
线程。
POSIX异步信号同时也是一个标准C库提供的功能，主要包括信号集管理（sigemptyset()、
sigfillset()、
sigaddset()、sigdelset()、sigismember()等）、信号处理函数安装（sigaction()）、信号阻塞控制
（sigprocmask()）、被阻塞信号查询（sigpending()）、信号等待(sigsuspend())等，它们与发送信号的kill()
等函数配合就能实现进程间异步信号功能。LinuxThreads围绕线程封装了sigaction()何raise()，本节集中讨论
LinuxThreads中扩展的异步信号函数，包括pthread_sigmask()、pthread_kill()和sigwait()三个函数。
毫无疑问，所有POSIX异步信号函数对于线程都是可用的。
int
pthread_sigmask(int how, const sigset_t *newmask, sigset_t
*oldmask)
设置线程的信号屏蔽码，语义与sigprocmask()相同，但对不允许屏蔽的Cancel信号和不允许响应的Restart信号进行了保护。被屏蔽的信号保存在信号队列中，可由sigpending()函数取出。
int
pthread_kill(pthread_t thread, int
signo)
向thread号线程发送signo信号。实现中在通过thread线程号定位到对应进程号以后使用kill()系统调用完成发送。
int
sigwait(const sigset_t *set, int
*sig)
挂
起线程，等待set中指定的信号之一到达，并将到达的信号存入*sig中。POSIX标准建议在调用sigwait()等待信号以前，进程中所有线程都应
屏蔽该信号，以保证仅有sigwait()的调用者获得该信号，因此，对于需要等待同步的异步信号，总是应该在创建任何线程以前调用
pthread_sigmask()屏蔽该信号的处理。而且，调用sigwait()期间，原来附接在该信号上的信号处理函数不会被调用。
如果在等待期间接收到Cancel信号，则立即退出等待，也就是说sigwait()被实现为取消点。
其他同步方式
除了上述讨论的同步方式以外，其他很多进程间通信手段对于LinuxThreads也是可用的，比如基于文件系统的IPC（管道、Unix域Socket等）、消息队列（Sys.V或者Posix的）、System
V的信号灯等。只有一点需要注意，LinuxThreads在核内是作为共享存储区、共享文件系统属性、共享信号处理、共享文件描述符的独立进程看待的。
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;
线程的分离状态
线程的分离状态决定一个线程以什么样的方式来终止自己。在默认情况下线程是非分离状态的，这种情况下，原有的线程等待创建的线程结束。只有当pthread_join（）函数返回时，创建的线程才算终止，才能释放自己占用的系统资源。
而
分离线程不是这样子的，它没有被其他的线程所等待，自己运行结束了，线程也就终止了，马上释放系统资源。程序员应该根据自己的需要，选择适当的分离状态。
所以如果我们在创建线程时就知道不需要了解线程的终止状态，则可以pthread_attr_t结构中的detachstate线程属性，让线程以分离状
态启动。
功能：
获取/修改线程的分离状态属性
头文件：
#include
函数原形：
int
pthread_attr_getdetachstate(const pthread_attr_t * attr,int
*detachstate);
int pthread_attr_setdetachstate(pthread_attr_t *attr,int
detachstate);
参数：
Attr 线程属性变量
Detachstate
线程的分离状态属性
返回值：
若成功返回0，若失败返回-1。
可
以使用pthread_attr_setdetachstate函数把线程属性detachstate设置为下面的两个合法值之一：设置为
PTHREAD_CREATE_DETACHED,以分离状态启动线程；或者设置为PTHREAD_CREATE_JOINABLE,正常启动线程。可以
使用pthread_attr_getdetachstate函数获取当前的datachstate线程属性。
以分离状态创建线程
#iinclude
void *child_thread(void *arg)
{
printf(“child thread
run!\n”);
}
int main(int argc,char *argv[
])
{
pthread_t
tid;
pthread_attr_t
attr;
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_DETACHED);
pthread_create(&tid,&attr,fn,arg);
pthread_attr_destroy(&attr);
sleep(1);
}
线程的继承性
函数pthread_attr_setinheritsched和pthread_attr_getinheritsched分别用来设置和得到线程的继承性，这两个函数的定义如下：
功能：
获得/设置线程的继承性
头文件：
#include
函数原形：
int pthread_attr_getinheritsched(const
pthread_attr_t *attr,int *inheritsched);
int
pthread_attr_setinheritsched(pthread_attr_t *attr,int
inheritsched);
参数：
attr
线程属性变量
inheritsched
线程的继承性
返回值：
若成功返回0，若失败返回-1。
这
两个函数具有两个参数，第1个是指向属性对象的指针，第2个是继承性或指向继承性的指针。继承性决定调度的参数是从创建的进程中继承还是使用在
schedpolicy和schedparam属性中显式设置的调度信息。Pthreads不为inheritsched指定默认值，因此如果你关心线程
的调度策略和参数，必须先设置该属性。
继承性的可能值是PTHREAD_INHERIT_SCHED（表示新现成将继承创建线程的调度策略和参数）和PTHREAD_EXPLICIT_SCHED（表示使用在schedpolicy和schedparam属性中显式设置的调度策略和参数）。
如果你需要显式的设置一个线程的调度策略或参数，那么你必须在设置之前将inheritsched属性设置为PTHREAD_EXPLICIT_SCHED.
- linux 线程学习
- linux C 线程学习
- linux线程学习
- Linux线程学习总结
- Linux线程学习笔记
- Linux 线程学习
- Linux线程学习(一)
- linux pthread线程学习
- linux 线程学习1
- linux线程学习-信号量
- linux 线程学习
- Linux学习--线程概念
- Linux学习--线程控制
- linux 线程学习
- linux线程进程学习
- Linux线程函数学习
- Linux线程学习总结
- linux 线程学习（一）
- 硬盘AHCI模式
- android html5<video> 视频播放
- 尚学堂 马士兵 struts_2视频教程 笔记心得 1——30课详解
- Android getDecorView用途——屏幕截图
- 代码质量(权威精选植根于开发实践的最佳读物)
- linux线程学习
- 1.一对一单向主键关联(人对身份证) 对象,hbm
- camera摄像原理之一：光感应
- C# 禁止应用程序多次启动
- HashSet的个人理解
- Vitamio FAQ
- pyQuery在python中，实现css选择器功能
- Android的framework层音量控制原理分析
- camera摄像原理之二：色彩空间
