线程同步

2．线程同步
POSIX支持用于短期锁定的互斥锁以及可以等待无限期限的条件变量。
在线程化程序中进行信号处理格外复杂，但是用专用线程来取代信号处理程序，可以降低其复杂性。
学习目标：互斥锁、条件变量、读--写锁、经典同步问题、带信号的线程

2.1POSIX同步函数
描 述 POSIX 函数
互斥锁
pthread_mutex_t pthread_mutex_destroy
pthread_mutex_init
pthread_mutex_lock
pthread_mutex_trylock
pthread_mutex_unlock
条件变量 pthread_cond_destroy
pthread_cond_init
pthread_cond_broadcast
pthread_cond_signal
pthread_cond_timewait
pthread_cond_wait
读--写锁 pthread_rwlock_destroy
pthread_rwlock_init
pthread_rwlock_rdlock
pthread_rwlock_wrlock
pthread_rwlock_timedrdlock
pthread_rwlock_timewrlock
pthread_rwlock_tryrdlock
pthread_rwlock_trywrlock

每种同步机制都提供了一个初始化函数和一个销毁对象的函数；
互斥锁和条件变量可以进行静态初始化；
每种同步机制都有与之相应的属性对象，也可使用默认的属性对象。

2.2互斥锁（或互斥量）
互斥量可以处于锁定状态，也可以处于解锁状态。
互斥量有一个等待该互斥量的线程队列，互斥量的等待队列中的线程顺序由调度策略确定。
互斥量只能短时间持有，等待输入这样的持续时间不确定的情况，用条件变量来同步。
互斥函数不是线程取消点，也不能被信号函数中断，除非线程终止或异步取消了线程。
2.2.1创建并初始化一个互斥量
POSIX用pthread_mutex_t类型表示互斥锁，程序在使用其同步之前必须对其初始化。
如果线程试图初始化一个已经被初始化的互斥量，POSIX中明确指出，该行为是为定义的，必须避免出现这种情况。
对静态分配的pthread_mutex_t只要将PTHREAD_MUTEX_INITIALIZER赋给变量就行了。
例：
pthread_mutex_t mylock = PTHREAD_MUTEX_INITIALIZER;
静态初始化程序比pthread_mutex_init更有效。
对动态分配或者没有默认互斥属性的pthread_mutex_t，要调用pthread_mutex_init初始化
#include <pthread.h>
int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);
attr为NULL则初始化一个带默认属性的互斥量。
成功返回0，不成功返回非零的错误码：
EAGAIN 系统缺乏初始化*mutex所需的非内存资源
ENOMEN 系统缺乏初始化*mutex所需的内存资源
EPERM 调用程序没有适当的优先级
例：
int error;
pthread_mutex_t mylock;
if ( (error = pthread_mutex_init(&mylock, NULL)) != 0 )
{
fprintf (stderr, “Failed to initialize mylock : %s/n”, strerror(error) );
exit(1);
}
2.2.2销毁一个互斥量
#include <pthread.h>
int pthread_mutex_destroy(pthread_mutex_t *mutex);
成功返回0，不成功返回非零的错误码，没有定义必须检测的错误。
例：
int error
pthread_mutex_t mylock;
if ( (error = pthread_mutex_destroy(&mylock)) != 0 )
{
fprintf (stderr, “Failed to destroy mylock : %s/n”, strerror(error));
exit(1);
}
pthread_mutex_init可以对已经被pthread_mutex_destroy销毁的变量进行重新初始化。
POSIX明确说明，以下两种情况的行为是为定义的，须避免：
线程引用已经销毁的互斥量；一个线程调用了pthread_mutex_destroy，而另一个将互斥量锁定。
2.2.3互斥量的锁定和解锁
#include <pthread.h>
int pthread_mutex_lock( pthread_mutex_t *mutex);
int pthread_mutex_trylock( pthread_mutex_t *mutex);
int ptrehad_mutex_unlock( pthread_mtex_t *mutex);
成功返回0，不成功返回非零的错误码，这三个函数必须检测相应的错误，以下是错误码：
EINVAL 互斥量具有协议属性PTHREAD_PRIO_PROTECT(该属性可以防止排序优先级反转的情况),而调用程序的优先级比互斥量当前的优先级的上限还要高(pthread_mutex_lock pthread_mutex_trylock)。
EBUSY 另一个线程持有锁（pthread_mutex_trylock）。
例：
pthread_mutex_t mylock = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_lock(&mylock);
/* critical section */
pthread_mutex_unlock(&mylock);
//代码省略了错误检测
2.2.4用互斥量保护不安全的库函数
可以使用互斥量保护不安全的库函数，POSIX标准将C库中的rand函数列为多线程化应用程序不安全的函数，如果能确保不会有两个函数同时调用它，就可以在一个多线程化的环境中使用rand函数。以下提供安全的例程
例：
#include <pthread.h>
#include <stdlib.h>

int randsafe(double *ranp)
{
static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
int error;

if ( (error = pthread_mutex_lock(&lock)) != 0 )
{
return error;
}
*ranp = ( rand() + 0.5 )/(RAND_MAX + 1.0 );
return pthread_mutex_unlock(&lock);
}
2.2.5用互斥量对标志符和全局值同步
#include <pthread.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <stdio.h>
#include <unistd.h>

#define TEN_MILLION 1000000L

static int doneflag = 0;
static pthread_mutex_t donelock = PTHREAD_MUTEX_INITIALIZER;

static int globalerror = 0;
static pthread_mutex_t errorlock = PTHREAD_MUTEX_INITIALIZER;

static int count = 0;
static double sum = 0.0;
static pthread_mutex_t sumlock = PTHREAD_MUTEX_INITIALIZER;

int randsafe(double *ranp)
{
static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
int error;

if ( (error = pthread_mutex_lock(&lock)) != 0 )
{
return error;
}

*ranp = (rand() + 0.5)/(RAND_MAX + 1.0);

return pthread_mutex_unlock(&lock);
}

int getdone(int *flag)
{
int error;
if ( (error = pthread_mutex_lock(&donelock)) != 0 )
{
return error;
}

*flag = doneflag;

return pthread_mutex_unlock(&donelock);
}

int setdone(void)
{
int error;
if ( (error = pthread_mutex_lock(&donelock)) != 0 )
{
return error;
}

doneflag = 1;

return pthread_mutex_unlock(&donelock);
}

int geterror(int *error)
{
int terror;

if ( (terror = pthread_mutex_lock(&errorlock)) != 0 )
{
return terror;
}

*error = globalerror;

return pthread_mutex_unlock(&errorlock);
}

int seterror(int error)
{
int terror;

if (error == 0)
{
return error;
}

if ( (terror = pthread_mutex_lock(&errorlock)) != 0 )
{
return terror;
}

if ( globalerror == 0 )
{
globalerror = error;
}

terror = pthread_mutex_unlock(&errorlock);
return terror>0 ? terror:error;
}


int add(double x)
{
int error;

if ( (error = pthread_mutex_lock(&sumlock)) != 0 )
{
return seterror(error);
}

sum += x;
count ++;

error = pthread_mutex_unlock(&sumlock);

return seterror(error);

}

int getsum(double *sump)
{
int error;

if ( (error = pthread_mutex_lock(&sumlock)) != 0 )
{
return seterror(error);
}

*sump = sum;

error = pthread_mutex_unlock(&sumlock);

return seterror(error);

}

int getcountandsum(int *countp, double *sump)
{
int error;

if ( (error = pthread_mutex_lock(&sumlock)) != 0 )
{
return seterror(error);
}

*countp = count;
*sump = sum;
error = pthread_mutex_unlock(&sumlock);

return seterror(error);
}




int showresults(void);
void *computethread(void *arg1)
{
int error;
int localdone = 0;
struct timespec sleeptime;
double val;

sleeptime.tv_sec = 0;
sleeptime.tv_nsec = TEN_MILLION;

while (localdone == 0)
{
if ( (error = randsafe(&val)) != 0 )
{
break;
}
if ( (error = add(sin(val))) != 0 )
{
break;
}
if ( (error = getdone(&localdone)) != 0 )
{
break;
}
nanosleep(&sleeptime, NULL);
}

seterror(error);
return NULL;

}





int main(int argc, char *argv[])
{
int error;
int i;
int numthreads;
int sleeptime;
pthread_t *tids;

if (argc != 3)
{
fprintf (stderr, "Usage: %s numthreads sleeptimes/n", argv[0]);
exit(1);
}

numthreads = atoi (argv[1]);
sleeptime = atoi (argv[2]);
if ( (tids = (pthread_t *)calloc (numthreads, sizeof(pthread_t))) == NULL )
{
perror("Failed to allocate space for thead IDs");
exit(2);
}

for (i=0; i<numthreads; i++)
{
if ( (error = pthread_create (tids+i, NULL, computethread, NULL)) != 0)
{
fprintf (stderr, "Failedt to start thread %d:%s/n", i, strerror(error));
exit(3);
}
}

sleep (sleeptime);

if ( (error = setdone()) != 0 )
{
fprintf (stderr, "Failed to set done:%s/n", strerror(error));
exit(4);
}

for (i=0; i<numthreads; i++)
{
if ( (error = pthread_join(tids[i], NULL)) != 0 )
{
fprintf (stderr, "Failed to join thread %d:%s/n", i, strerror(error));
exit(5);
}
}

if ( showresults() != 0 )
{
exit(6);
}

exit(0);
}




int showresults(void)
{
double average;
double calculated;
int count;
double err;
int error;
int gerror;
double perr;
double sum;

if ( ((error = getcountandsum(&count, &sum)) != 0)
|| ((error = geterror(&gerror)) != 0) )
{
fprintf (stderr, "Failed to get results: %s/n", strerror(error));
return -1;
}

if (gerror != 0)
{
fprintf (stderr, "Failet to compute sum:%s/n", strerror(gerror));
return -1;
}

if (count == 0)
{
printf ("NO value were summed./n");
}
else
{
calculated = 1.0 -cos(1.0);
average = sum/count;
err = average - calculated;
perr = 100.0*err/calculated;
printf ("The sum is %f and the count is %d/n", sum, count);
printf ("The average is %f and error is %f or %f%%/n", average, err, perr);
}

return 0;
}
./mutex 2 1
The sum is 121.423602 and the count is 254
The average is 0.478046 and error is 0.018348 or 3.991315%

2.2.6用互斥量使数据结构成为线程安全的
线程化程序中大多数共享的数据结构都必须由同步机制保护，以确保能得到正确的结果。
实现只需要将每个函数都包装在一对互斥调用中。

2.3最多一次和最少一次的执行
最多一次和最少一次，对初始化来说非常重要。换句话说，初始化的工作正好执行一次。有时程序结构保证最少执行一次，这是时就需要结合最多一次的策略来保证正好执行一次。
以下讨论最多执行一次常用的策略：
单次初始化的概念非常重要，例如为一个已经初始化的互斥量调用pthread_mutex_init所产生的效果是为定义的。
所以，POSIX提供了pthread_once函数确保这个语义的实现。
#include <pthread.h>
int pthread_once(pthread_once_t *once_control,
void (*init_routine)(void))； //动态初始化
函数成功返回0，不成功返回非零的错误码，没有定义必须检测的错误类型
pthread_once_t once_control = PTHREAD_ONCE_INIT; //静态初始化
例1：最多执行一次
用pthread_once来初始化一个变量，并且打印出一条语句的函数
#include <pthread.h>
#include <stdio.h>

static pthread_once_t initonce = PTHREAD_ONCE_INIT;
int var;

static void initialization(void)
{
var = 1;
printf(“The variable was initialized to %d/n”, var);
}

int printfinitonce(void)
{
return pthread_once(&initonce, initialization);
}
函数initialization最多执行一次
例2：最多执行一次
#include <pthread.h>
#include <stdio.h〉
int printinitmutex(int *var, int value)
{
int error;
static int done = 0;
static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;

if ( (error = pthread_mutex_lock(&lock)) != 0 )
{
return error;
}
if ( done == 0 )
{
*var = value;
printf (“The variable was initialized to %d/n”, value);
done = 1;
}
return pthread_mutex_unlock(&lock);
}
讨论1：如果去除done和lock的static限定符会发生如下结果
结果：在一个块的内部作用于变量的static限定符确保了他们在块的后继执行过程中始终存在。若果没有static修饰，done和lock就变成了自动变量。在这种情况下，每个队printinitmutex的调用都会分配新的变量，而每次return都会释放掉这些变量，函数将不再工作。
讨论2：将done和lock的申明放到printinitmutex函数外，结果如下
结果：函数printinitmutex可以正常工作。但是，定义在同一个文件中的其他函数就可以访问done和lock了。将他们保持在函数内部可以更安全的保证”最多一次”

2.4条件变量
条件变量是线程可以使用的另一种同步机。条件变量给多个线程一个会合的场所。条件变量与互斥量一起使用时，允许线程以无竞争的方式等待特定的条件发生。
考虑如下问题：
假设两个变量x和y被多个线程共享。我们希望线程一直等到x和y相等为止。
典型的不正确的忙等解决方法是：while(x != y);
根据线程的调度方式，执行忙等的线程可能永远都不会让其他的线程使用cpu，这样x和yde 值永远也不会变了。同时对共享变量的访问也应该被保护起来。
等待断言x==y 为真的正确的非忙等策略：
a.锁定互斥量
b.测试条件x==y
c.如果为真，解除对互斥量的锁定，并推出循环
d.如果为假，将线程挂起，并解除对互斥量的锁定
问题在于：如何保证解除互斥量的锁定和线程挂起之间x和y没有发生改变。
解决办法：解除锁定和挂起必须是原子操作（pthread_cond_wait）。
2.4.1创建和销毁条件变量
POSIX用pthread_cond_t类型的变量来表示条件变量。
将NULL传给attr将用默认属性初始化一个条件变量
创建：
#include <pthread.h>
int pthread_cond_init(pthread_cond_t cond, const pthread_condattr_t *restrict attr);
//动态初始化
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
//静态初始化
函数pthread_cond_init成功返回0，不成功返回非零的错误码：
EAGAIN 系统缺乏初始化*cond所需要的非内存资源
ENOMEM 系统缺乏初始化*cond所需要的内存资源
销毁：
#include <pthread.h>
int pthread_cond_destroy(pthread_cond_t *cond);
成功返回0，不成功返回非零的错误码，没有定义必须检测的错误码。
试图初始化一个已经被初始化了的条件变量；引用一个已经被销毁的条件变量；销毁一个使其他线程阻塞了的条件变量，这些行为都是为定义的。尽量避免
2.4.2等待和通知条件变量
条件变量是和断言（条件测试）一起调用的。条件变量的名字就是同这个断言相关联的。
通常线程会对一个条件进行测试，测试失败，就调用pthread_cond_wait或pthread_cond_timewait。
函数中cond指向条件变量，mutex指向互斥量，线程在调用之前应该拥有这个互斥量。当线程被放在条件变量等待队列中是，等待队列会使线程释放这个互斥量。
函数pthread_cond_timewait的第三个参数是一个指向返回时间的指针，这个时间是绝对时间而不是时间间隔。
等待：
#include <pthread.h>
int pthread_cond_wait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex);
int pthread_cond_timewait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex,
const struct timespec *restrict abstime);
成功返回0，不成功返回非零的错误码；abstime指定的时间到期，则返回ETIMEOUT。
例：使线程（非忙）等待，直到a大于或等于b为止(清楚起见省略了错误检测)
static pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; //变量类型必须是静态
pthread_mutex_lock(&mutex); //调用pthread_cond_wait之前线程必须拥有互斥量
while(a < b) //pthread_cond_wait返回之后必须再次检测条件是否满足
{
pthread_cond_wait(&cond, &mutex); //原子的释放互斥量，并阻塞
}
pthread_mutex_unlock(&mutex);
pthread_cond_wait返回有可能是假唤醒，因为只要条件测试中涉及的变量改变就会通知条件变量的等待队列，函数返回只能说明变量有改变，必须重新进行测试，不满足则继续阻塞。
pthread_cond_wait只是提供解锁和阻塞线程的原子操作，并提供线程排队功能，当条件改变时对互斥量加锁返回。条件变量可以看成是队列的名称（自己定义的）
通知：
当一个线程改变了可能会使断言成真的变量时，他应该唤醒一个或多个在等待断言成真的线程。
pthread_cond_signal函数至少解除了一个阻塞在cond指向的条件变量上的线程的阻塞。
pthread_cond_broadcast函数解除所有阻塞在cond指向的条件变量上的线程的阻塞。
但是，这两个函数只是解除线程在条件变量上的阻塞，并没有解除互斥量上的阻塞。
#include <pthread.h>
int pthread_cond_signal(pthread_cond_t *cond);
int pthread_cond_broadcast(pthread_cond_t *cond);
一些使用条件变量必须遵守的规则：
a.测试断言之前获得互斥量。
b. pthread_cond_wait返回之后重新对断言进行测试。
因为返回可能是由某些不相关的事件或无法使断言成真的pthread_cond_signal引起的，
c.在修改断言中出现的任一互斥量之前，要获得互斥量。
d.通常测试断言或者修改共享变量的应用中，使用互斥量这种短时间锁定的策略
e.pthread_mutex_unlock显示地释放互斥量，
pthread_cond_wait隐式地释放互斥量。

2.5读写锁
一次只有一个线程可以占有写模式的读写锁，但是多个线程可以同时占有读模式的读写锁，
而互斥量只能同时有一个线程加锁。
当读写锁是写加锁状态时，在解锁之前试图对这个锁加锁的线程都会被阻塞。
当读写锁是读加锁状态时，所有以读模式对他进行加锁的线程都可以得到访问权；所有希望以写模式对此锁进行加锁的线程，必须阻塞直到所有的线程释放读锁（这种情况下读写锁通常会阻塞随后的读模式锁请求，避免读模式锁长期占用，而等待的写模式所请求得不到满足）。
2.5.1创建和销毁
与互斥量一样pthread_rwlock_t 表示读写锁
创建：
#include <pthread.h>
int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock,
const pthread_rwlockattr_t *restrict attr);
attr为NULL时，以默认属性创建读写锁
成功返回0，不成功返回非零的错误码，函数必须检测的错误码：
EAGAIN 系统缺乏初始化*rwlock所需的非内存资源
ENOMEM 系统缺乏初始化*rwlock所需的内存资源
EPERM 调用程序没有适当的权限
销毁：
#include <pthread.h>
int pthread_rwlock_destroy(pthread_rwlock *rwlock);
成功返回0，不成功就返回一个错误码，没有定义必须检测的错误。
试图初始化一个已经初始化了的读写锁，引用一个已经销毁的读写锁，结果都是未定义的。
2.5.2加锁和解锁
pthread_rwlock_rdlock和pthread_rwlock_wrlock函数一直阻塞，直到锁可用为止；
pthread_rwlock_tryrdlock和pthread_rwlock_trywrlock函数会立即返回（EBUSY）。
#include <pthread.h>
int pthread_rwlock_rdlock(pthread_rwlock_ t *rwlock);
int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);
成功返回0，不成功返回非零的错误码；
如果锁已经被持有，而无法获取，pthread_rwlock_tryrdlock和pthread_rwlock_trywrlock返回EBUSY。
情况1：如果线程在一个已经用pthread_rwlock_wrlock获取的锁上调用pthread_rwlock_rdlock
结论：POSIX申明，有可能会出现死锁
情况2：如果线程在一个已经用pthread_rwlock_rdlock获取的锁上调用pthread_rwlock_rdlock
结论：线程会持有同一个读写锁上的多个并发的读锁。应该确保解除锁定调用的数目和锁定调用的数目项匹配，以释放锁定。
2.5.3读写锁和互斥锁的比较
互斥锁是一种低开销的同步机制，如果程序中函数只需要在很短的一段时间持有锁，那么互斥锁是相对高效的；
读写锁有一些开销，所以，当实际的读操作要花费相当长的时间的时候（如访问磁盘引起的读操作），他们的优点就显现出来了。在这种情况下，严格的线性执行效率是很低的。

2.6线程与信号处理
进程中所有线程都共享进程的信号处理函数，但每个线程都有它自己的信号掩码。
如果有几个线程都解除了对同一个异步信号的阻塞，系统就从中挑选一个来处理信号。
线程中信号传递的类型
异步：传递给某些解除了对该信号的阻塞的线程
同步：传递给引发（该信号）的线程
定向：传递给标识了的线程（pthread_kill）
2.6.1将信号定向到一个特定的线程中
pthread_kill 函数产生信号码为sig的信号，并将其传送到thread指定的线程中去。
#include <pthread.h>
#include <signal.h>
int pthread_kill(pthread_t thread, int sig);
成功返回0，不成功返回非零的错误码并且无信号发送出去，必须检测的错误码：
EINVAL sig是无效的或不被支持的信号码
ESRCH 没有现成对应于指定的ID
例：下面的代码段会使线程将它自己和整个进程都杀死，尽管pthread_kill将信号传递给了一个特定的线程，但处理信号的行为将影响到整个进程。（默认行为是终止进程的信号都是这个结果）。
if (pthread_kill(pthread_self(), SIGKILL) != 0)
{
fprintf (stderr, “Failed to commit suicide/n”);
}
2.6.2为线程屏蔽信号
每个线程都有它自己的信号掩码。sigprocmask函数在创建其他线程之前，可以被逐线程调用。但当进程中有多个线程是就应该使用pthread_sigmask函数
#include <pthread.h>
#include <signal.h>
int pthread_sigmask(int how, const sigset_t *restrict set, sigset_t *restrict oset);
成功返回0，不成功返回非零的错误码，
EINVAL 参数how 无效
how的取值：
SIG_SETMASK 会使线程的信号掩码被set取代，阻塞set中所有的信号，但不阻塞其他
SIG_BLOCK 将set中的信号添加到现成现有的信号掩码中（阻塞包括set中的信号）
SIG_UNBLOCK 从线程当前的信号掩码中将set中的信号删除（不再阻塞set中的信号）
2.6.3线程等待一个或多个信号发生
#include <signal.h>
int sigwait(const sigset_t *restrict set, int *restrict signop);
成功返回0，不成功返回非零的错误码
set参数指定了线程等待的信号集，signop指向的整数将作为返回值，表明发送信号的数量。
如果信号集中的某个信号在sigwait调用的时候处于未决状态，那么sigwait将会无阻塞的返回，返回之前，sigwait将从进程中移出那些处于未决状态的信号。
如果多个线程在sigwait调用时，等待同一个信号，这是就会出现线程阻塞，当信号递送时，只有一个线程可以从sigwait中返回。
注意：为避免错误，线程在调用sigwait之前，必须阻塞那些他正在等待的信号。sigwait函数会自动取消信号集的阻塞状态，直到新的信号被递送。在返回之前，sigwait会恢复线程的信号屏蔽字。
2.6.3为信号处理指定专用的线程（多线程的进程中进行信号处理的推荐策略）
为了防止信号中断线程，可以把信号加到每个线程的信号屏蔽字中，然后安排专用线程作信号处理。这些专用线程可以进行函数调用，不需要担心那些函数是安全的，因为他们的调用来自正常的线程环境，而非传统的信号处理程序，传统的信号处理程序通常会中断线程的正常执行。
具体：主线程在创建线程之前阻塞所有的信号。信号掩码是从创建线程中继承的。这样，所有的线程都将信号阻塞了。然后，专门用来处理信号的线程对那个信号执行sigwait。
例：
#include <pthread.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>


int quitflag;
sigset_t mask;

pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t wait = PTHREAD_COND_INITIALIZER;




void *thr_fn(void *arg)
{
int err;
int signo;

for(;;)
{
err = sigwait(&mask, &signo);
if (err != 0)
{
fprintf (stderr, "sigwait failed/n");
exit(1);
}

switch (signo)
{
case SIGINT:
{
printf("/ninterrupt/n");
break;
}
case SIGQUIT:
{
pthread_mutex_lock(&lock);
quitflag = 1;
pthread_mutex_unlock(&lock);
pthread_cond_signal(&wait);
return (0);
}
default:
{
printf("unexpeted signal %d/n", signo);
exit(1);
}

}
}
}


int main(void)
{
int err;
sigset_t oldmask;
pthread_t tid;

sigemptyset (&mask);
sigaddset (&mask, SIGINT);
sigaddset (&mask, SIGQUIT);

if ( (err = pthread_sigmask(SIG_BLOCK, &mask, &oldmask)) != 0 )
{
fprintf (stderr, "SIG_BLOCK ERROR/n");
exit(1);
}

err = pthread_create(&tid, NULL, thr_fn, NULL);
if (err != 0)
{
fprintf (stderr, "pthread_cteate error/n");
exit(2);
}

pthread_mutex_lock(&lock);
while (quitflag == 0)
{
pthread_cond_wait(&wait, &lock);
}
pthread_mutex_unlock(&lock);

quitflag = 0;

if (sigprocmask(SIG_SETMASK, &oldmask, NULL) < 0)
{
fprintf (stderr, "SIG_SETMASK error/n");
exit(2);
}

exit(0);
}
线程在开始阻塞SIGINT和SIGQUIT。新建线程继承了现有的信号屏蔽字。
因为sigwait会解除信号的阻塞状态，所以只有一个线程用于信号的接收。这使得对主线程进行编码是不必担心来自这些信号的中断。

2.7线程和fork（略）
线程和进程交互

2.8线程和IO
因为进程中的所哟欧线程共享相同的文件描述符。
考虑两个线程，在同一时间对同一个文件描述符进行读写操作
线程A 线程B
lseek(fd, 300, SEEK_SET); lseek(fd, 700, SEEK_SET);
read(fd, buf1, 100); read(fd, buf2, 100);
如果线程A执行lseek,然后线程B在线程A调用read之前调用lseek，那么两个线程最终会读取同一个记录。
为解决这个问题可以使用pread pwrite把偏移量的设定和数据的读写成为一个原子操作。
pread(fd, buf1, 100, 300); pread(fd, buf2, 100, 700);

2.9线程和信号安全的strerror和perror版本
用sigprocmask阻塞信号
用pthread_mutex_lock保持互斥访问
#include <errno.h>
#include <pthread.h>
#include <signal.h>
#include <stdio.h>
#include <string.h>

static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;


int strerror_r (int errnum, char *strerrbuf, size_t buflen)
{
char *buf;
int error1;
int error2;
int error3;
sigset_t maskblock;
sigset_t maskold;

if ( (sigfillset(&maskblock) == -1) ||
(sigprocmask(SIG_SETMASK, &maskblock, &maskold) == -1) )
{
return errno;
}
if ( error1 = pthread_mutex_lock(&lock) )
{
(void)sigprocmask(SIG_SETMASK, &maskold, NULL);
return error1;
}

buf = strerror(errnum);
if ( strlen(buf) >= buflen )
{
error1 = ERANGE;

}
else
{
(void *)strcpy(strerrbuf, buf);
}

error2 = pthread_mutex_unlock(&lock);
error3 = sigprocmask(SIG_SETMASK, &maskold, NULL);

return error1?error1:(error2?error2:error3);
}


int perror_r(const char *s)
{
int error1;
int error2;
sigset_t maskblock;
sigset_t maskold;

if ( (sigfillset(&maskblock) == -1) ||
(sigprocmask(SIG_SETMASK, &maskblock, &maskold) == -1) )
{
return errno;
}

if( error1 = pthread_mutex_lock(&lock) )
{
(void)sigprocmask(SIG_SETMASK, &maskold, NULL);
return error1;
}

perror(s);
error1 = pthread_mutex_unlock(&lock);
error2 = sigprocmask(SIG_SETMASK, &maskold, NULL);
return error1?error1:error2;
}