《UNIX环境高级编程》第11章 线程

11.1 引言

前面讨论了进程，学习了UNIX进程的环境、进程间的关系以及控制进程的不同方式。
本章将进一步深入理解进程，了解如何使用多个控制线程（线程）在单进程环境中执行多个任务。一个进程中的所有线程都可以访问该进程的组成部件，如文件描述符和内存。
不管什么情况下，只要单个资源需要在多个用户间共享，就必须处理一致性问题。本章的最后将讨论目前可用的同步机制，防止多个线程在共享资源时出现不一致的问题。

11.2 线程概念

典型的UNIX进程可以看成只有一个控制线程：一个进程在某一时刻只能做一个件事情。有了多个控制线程之后，在程序设计时就可以把进程设计成在某一时刻能够做不止一件事，每个线程处理各自独立的任务。、

• 通过为每种时间类型分配单独的处理线程，可以简化异步事件的代码。
• 多个进程必须使用操作系统提供的复杂机制才能实现内存和文件描述符的共享。而多个线程自动地可以访问相同的存储地址空间和文件描述符。
• 有些问题可以分解从而提高整个程序的吞吐量。在只有一个控制线程的情况下，一个单线程进程要完成多个任务，只需要把这些任务串行化。但有多个控制线程时，相互独立的任务的处理就可以交叉进行，此时只需要为每个任务分配一个单独的线程。当然只有在两个任务处理互不依赖的情况下，两个任务才可以交叉执行。
• 交互的程序通常可以通过使用多线程来改善响应时间，多线程可以把程序中处理用户输入输出的部分与其他部分分开。

有些人把多线程的程序设计与多处理器或多核系统联系起来。但是即使程序运行在单处理器上，也能得到多线程模型的好处。处理器的数量并不影响程序结构，所以不管处理器的个数多少，程序都可以通过使用线程得以简化。而且，即使多线程程序咋串行化任务时不得不阻塞，由于某些线程在阻塞的时候还有另外一些线程可以运行，所以多线程程序在单处理器上运行还是可以改善响应时间和吞吐量。

---

每个线程都包含有表示执行环境所必须的信息，其中包括进程中标识线程的线程ID、一组寄存器值、栈、调度优先级和策略、信号屏蔽字、errno变量以及线程私有数据。
一个进程的所有信息对该进程的所有线程都是共享的，包括可以执行程序的代码、程序的全局内存和堆内存、栈以及文件描述符。

---

我们将要讨论的线程接口来自POSIX.1。线程接口也称为“pthread”或“POSIX 线程”。
POSIX 线程的功能测试宏是_POSIX_THREADS,应用程序可以把这个宏用于#ifdef测试，从而在编译时确定是否支持线程；
也可以把常数_SC_THREADS用于调用sysconf函数，进而在运行时确定是否支持线程。

11.3 线程标识

就像每个进程都有一个进程ID一样，每个线程也有一个线程ID。进程ID在整个系统中是唯一的，但线程ID不同，线程ID只有在它所属的进程上下文中才有意义。
线程ID用pthread_t数据类型来表示，实现的时候可以用一个结构来代表pthread_t数据类型，所有可移植的操作系统实现不能把它当做整数处理。因此必须使用一个函数对两个线程ID进程比较。

#include <pthread.h>
int pthread_equal(pthread_t tid1,pthread_t tid2);

使用结构表示pthread_t数据类型的后果是不能使用一种可移植的方式打印该数据类型的值。

---

线程可以使用pthread_self函数获得自身的线程ID。

#include <pthread.h>
pthread_t pthread_self(void);

当线程需要识别以线程ID作为标识的数据结构时，pthread_self函数可以与pthread_equal函数一起使用。例如：
主线程可能把工作任务放在一个队列中，用线程ID来控制每个工作线程处理哪些作业。如下图，主线程把新的作业放到一个工作队列中，由3个线程组成的线程池从队列中移除作业。主线程不允许每个线程任意处理从队列顶端取出的作业，而是由主线程控制作业的分配，主线程会在每个待处理作业的结构中放置处理该作业的线程ID，每个工作线程只能移除标有自己线程ID的作业。

11.4 线程创建

在传统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);

• 参数tidp所指向的内存单元存储了新线程的线程ID；
• 参数attr用于定制不同的线程属性。可以设置为NULL，创建一个具有默认属性的线程。
• 新创建的线程从start_rtn函数的地址开始运行，该函数只有一个无类型参数指针arg，如果需要向start_rtn函数传递的参数有一个以上，那么需要把这些参数放到一个结构中，然后把这个结构的地址作为arg参数传入。

线程创建时并不能保证哪个线程会先运行：是新创建的线程，还是调用线程。新创建的线程可以访问进程的地址空间，并且继承了调用线程的浮点环境和信号屏蔽字，但是该线程的挂起信号集会被清除。

---

pthread函数在调用失败时会返回错误码，它们并不像其他POSIX函数一样设置errno。每个线程都提供errno的副本，这只是为了与使用errno的现有函数兼容。

---

#include <stdio.h>
#include <stdlib.h>

#include <pthread.h>

void printSysInfo(char *);
void *newThread(void *);


void printSysInfo(char *str)
{
    pid_t pid;
    pthread_t tid;

    pid=getpid();
    tid=pthread_self();

    printf("%s :pid is %ld,tid is %ld.\n",str,pid,tid);
}

void *newThread(void *arg)
{


    printf("the argument is %s. \n",(char *)arg);

    printSysInfo("in new thread");

    return((void *)0);

}


int main(void)
{
    pthread_t tid;
    int err;
    char *str="hello!";
    err=pthread_create(&tid,NULL,newThread,str);
    printSysInfo("in main thread");
    sleep(1);
    return 0;
}

11.5 线程终止

如果进程中的任意线程调用了exit、_Exit或者_exit，那么整个进程就会终止。如果默认动作是终止的信号发送到线程，那么发送到线程的信号就会终止整个进程（12.8节再讨论信号与线程时如何交互的）。
单个线程可以通过3种方式退出，因此可以在不终止整个进程的情况下，停止它的控制流。

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);

调用线程将一直阻塞，直到指定的线程调用pthread_exit、从启动例程返回或者被取消。如果线程简单地从启动例程中返回，rval_ptr就包含返回码。如果线程被（其他线程）取消，rval_ptr指定的内存单元被设置为PTHREAD_CANCELED。
如果对线程的返回值并不感兴趣，那么可以把rval_ptr设置为NULL。这种情况下，调用pthread_join函数可以等待指定线程终止，但并不获取线程的终止状态。

#include <stdio.h>
#include <stdlib.h>

#include <pthread.h>

void *newThread1(void *);
void *newThread2(void *);



void *newThread1(void *arg)
{


    printf("in thread 1. \n");


    return((void *)1);  //情况1.正常返回

}

void *newThread2(void *arg)
{

    printf("in thread 2. \n");

    pthread_exit((void *)3);  //情况2.pthread_exit返回
    //addr 0x03

}



int main(void)
{
    pthread_t tid1,tid2;
    int err;
    int *retNum;  //用于接收return或pthread_exit返回指针的指针变量

    err= pthread_create(&tid1,NULL,newThread1,NULL);
    err= pthread_create(&tid2,NULL,newThread2,NULL);

    pthread_join(tid1,&retNum);  //二重指针是提供用于接收返回指针的指针变量的地址
    printf("thread1 return %d \n",retNum);

    pthread_join(tid2,&retNum);
    printf("thread2 return %d \n",retNum);

    sleep(1);
    return 0;
}

一个C语言的基本概念：函数不能返回栈上变量的地址。自动变量内存地址中的值在函数退出后是不确定的。尤其在上面这些返回指针的地方。要不然返回只读数据区中的常量，要不然就是malloc堆中的动态变量，要不然就是全局变量。

---

线程可以通过调用pthread_cancel函数来请求取消同一进程中的其他线程。

#include <pthread.h>
int pthread_cancel(pthread_t tid);

在默认情况下，pthread_cancel函数会使得由tid标识的线程的行为表现为如同调用了参数为PTHREAD_CANCELED的pthreas_exit函数。但是线程可以忽略取消或者控制如何被取消(在后面12章讨论)。注意：pthread_cancel并不等待线程终止，它仅仅提出请求。
线程可以安排它退出时需要调用的函数，这与进程在退出时可以调用atexit函数安排退出时类似的。这样的函数称为线程清理处理程序（thread cleanup handler）。一个线程可以建立多个清理处理程序。处理程序注册在栈中，也就是说，它们执行的顺序与它们注册的顺序相反。

#include <pthread.h>
void pthread_cleanup_push(void (*rtn)(void *),void *arg);
void pthread_cleanup_pop(int execute);

当线程执行以下动作时，清理函数rtn是由pthread_cleanip_push函数调度的，调用时只有一个参数arg：

1. 调用pthread_exit时；
2. 响应取消请求时；
3. 用非零execute参数调用pthread_cleanup_pop时。
4. 注意！！线程从启动例程返回（正常退出）并不会调用注册的清理程序。
   如果execute参数设置为0，清理函数将不被调用。不管发生上述哪种情况，pthread_cleanup_pop都将删除上次pthread_cleanip_push调用建立的清理处理程序。
   这些函数有一个限制，由于它们可以实现为宏，所以必须在线程相同的作用域中以匹配对的形式使用。因为pthread_cleanip_push包含了’{‘字符,pthread_cleanup_pop包含了’}’字符.

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


void *fun1(void *arg);
void *fun2(void *arg);

void cleanup(void *arg);


void *fun1(void *arg)
{
    printf("thread1 printed the message.\n");

    pthread_cleanup_push(cleanup,"thread 1 first handler");
    pthread_cleanup_push(cleanup,"thread 1 second handler");

    if(arg)
        return((void *)1);
    pthread_cleanup_pop(0);
    pthread_cleanup_pop(0);

    return((void *)1);
}

void *fun2(void *arg)
{
    printf("thread2 printed the message.\n");

    pthread_cleanup_push(cleanup,"thread 2 first handler");
    pthread_cleanup_push(cleanup,"thread 2 second handler");

    if(arg)
        pthread_exit((void *)2);
    pthread_cleanup_pop(0);
    pthread_cleanup_pop(0);

    pthread_exit((void *)2);
}

void cleanup(void *arg)
{
    printf("%s. \n",arg);
}




int main(void)
{
    pthread_t tid1,tid2;
    void *tret;

    pthread_create(&tid1,NULL,fun1,1);
    pthread_create(&tid2,NULL,fun2,1);

    pthread_join(tid1,&tret);
    printf("thread1 return %d. \n",tret);
    pthread_join(tid2,&tret);
    printf("thread2 return %d \n",tret);

    return 0;
}

---

线程函数与进程函数之间的相似处：

进程原语	线程原语	描述
fork	pthread_create	创建新的控制流
exit	pthread_exit	从现有的控制流中退出
waitpid	pthread_join	从控制流中得到退出状态
atexit	pthread_cleanup_push	注册在退出控制流时调用的函数
getpid	pthread_self	获得控制流ID
abort	pthread_calcel	请求控制流的非正常退出

在默认情况下，线程的终止状态会保存直到对该线程调用pthread_join。如果线程已经被分离，线程的底层存储资源可以在线程终止时立即被收回。在线程被分离后，我们不能调用pthread_join 函数等待它的终止状态，因为对分离状态的线程调用pthread_join会产生未定义行为。
可以调用pthread_detach分离线程。

#include <pthread.h>
int pthread_detach(pthread_t tid);

11.6 线程同步

当多个控制线程共享相同的内存时，需要确保每个线程看到一致的数据视图。如果每个线程使用的变量都是其他线程不会读取和修改的，那么就不存在一致性问题。同样，如果变量是制度的，多个线程同时读取该变量也不会有一致性问题。但是，当一个线程可以修改的变量，其他线程也可以读取或修改的时候，我们就需要对这些线程进行同步，确保它们在访问变量的存储内容时不会访问到无效的值。
当一个线程修改变量时，其他线程在读取或修改这个变量时可能会看到一个不一致的值。
为了解决这个问题，线程不得不使用锁，同一时间只允许一个线程访问该变量。

11.6.1 互斥量mutex

可以使用pthread的互斥接口来保护数据，确保同一时间只有一个线程访问数据。互斥量（mutex）从本质上说是一把锁，在访问共享资源前对互斥量进行设置（加锁），在访问完成后释放（解锁）互斥量。对互斥量进行加锁以后任何其他试图再次对互斥量加锁的线程都会被阻塞直到当前线程释放该互斥锁。
如果释放互斥量时有一个以上的线程阻塞，那么所有该锁上的阻塞线程都会变成可运行状态，第一个变为可运行的线程就可以对互斥量加锁，其他线程就会看到互斥量依然是锁着的，只能回去再次等待它重新变为可用。在这种方式下，每次只有一个线程可以向前执行。
互斥变量是用pthread_mutex_t数据类型表示的。在使用互斥变量以前，必须首先对它进行初始化，可以把它设置为常量PTHREAD_MUTEX_INITIALIZER（只适用于静态分配的互斥量），也可以通过调用pthread_mutex_init函数进行初始化。如果动态分配互斥量（例如，通过调用malloc函数），在释放内存前需要调用pthread_mutex_destroy。

#include<pthread.h>
int pthread_mutex_init(pthread_mutex_t *restrict mutex,const pthread_mutexattr_t *restrict attr);    //默认属性为NULL
int pthread_mutex_dstroy(pthread_mutex_t *mutex);

对互斥量进行加锁，需要调用pthread_mutex_lock。如果互斥量已经上锁，调用线程将阻塞直到互斥量被解锁。对互斥量解锁需要调用pthread_mutex_unlock。

#include<pthread.h>
int pthread_mutex_lock(pthread_mutex_t *mutex);
int pthread_mutex_trylock(pthread_mutex_t *mutex);
int pthread_mutex_unlock(pthread_mutex_t *mutex);

如果线程不希望被阻塞，它可以使用pthread_mutex_trylock尝试对互斥量进行加锁。如果调用pthread_mutex_trylock时互斥量处于未锁住状态，那么pthread_mutex_trylock将锁住互斥量，不会出现阻塞直接返回0，否则就会失败，不能锁住互斥量，返回EBUSY。

11.6.2 避免死锁

如果线程试图对同一个互斥量加锁两次，那么它自身就会陷入死锁状态，但是使用互斥量时，还有其他不太明显的方式也能产生死锁。例如程序中使用一个以上的互斥量时，如果允许一个线程一直占有第一个互斥量，并且在试图锁住第二个互斥量时处于阻塞状态，但是拥有第二个互斥量的线程也在试图锁住第一个互斥量。因为两个线程都在相互请求另一个线程拥有的资源，所以这两个线程都无法向前运行，于是就产生死锁。

11.6.3 函数pthread_mutex_timedlock

当线程试图获取一个已经加锁的互斥量时，pthread_mutex_timedlock互斥量原语允许绑定线程阻塞时间。pthread_mutex_timedlock函数与pthread_mutex_lock函数基本上是等价的，但是在达到超时时间值时，pthread_mutex_timedlock不会对互斥量进行加锁，而是返回错误码ETIMEDOUT。

#include <pthread.h>
#include <time.h>
int pthread_mutex_timedlock(pthread_mutex_t *restrict mutex,const struct timespec *restrict tsptr);

超时指定愿意等待的绝对时间（注意是绝对时间）。这个超时时间是用timespec结构来表示的，它用秒和纳秒来描述时间。
以下的例子给出了如何用pthread_mutex_timedlock避免永久阻塞。

#include <stdio.h>
#include <pthread.h>
#include <time.h>
#include <error.h>
#include <errno.h>
#include <err.h>
#include <string.h>



int main(void)
{
    int err;
    struct timespec tout;
    struct tm *tmp;
    char buf[64];
    pthread_mutex_t lock=PTHREAD_MUTEX_INITIALIZER;

    pthread_mutex_lock(&lock);
    printf("mutex is locked. \n");

    clock_gettime(CLOCK_REALTIME,&tout);
    tmp=localtime(&tout.tv_sec);
    strftime(buf,sizeof(buf),"%r",tmp);
    printf("current time is %s \n",buf);
    tout.tv_sec+=10;

    err=pthread_mutex_timedlock(&lock,&tout);

    clock_gettime(CLOCK_REALTIME,&tout);
    tmp=localtime(&tout.tv_sec);
    strftime(buf,sizeof(buf),"%r",tmp);
    printf("current time is %s \n",buf);

    if(err==0)
        printf("mutex locked again! \n");
    else
        printf("can not lock  mutex again:%s \n",strerror(err));

    return 0;
}

11.6.4 读写锁

读写锁（read-write-lock）与互斥量类似，不过读写锁允许更高的并行性。互斥量要么是锁住状态，要么就是不加锁状态，而且一次只有一个线程可以对其加锁。
读写锁有3种状态：读模式下加锁状态，写模式下加锁状态，不加锁状态。一次只有一个线程可以占有写模式的读写锁，但是多个线程可以同时占有读模式的读写锁。

• 读写锁是写加锁状态时，在这个锁被解锁之前，所有试图对这个锁加锁的线程都会被阻塞。
• 读写锁是读加锁状态时，所有试图以读模式对它进行加锁的线程都可以得到访问权，但是任何希望以写模式对此锁进行加锁的线程都会阻塞，直到所有线程释放它们的读锁为止。
• 当读写锁处于读模式锁住状态时，有一个线程试图以写模式获取锁时，读写锁通常会阻塞随后的读模式锁请求。这样可以避免读模式锁长期占有，而等待的写模式锁请求一直得不到满足。

---

读写锁非常适合于对数据结构读的次数远大于写的情况。当读写锁在写模式下时，他所保护的数据结构就可以安全地修改，因为一次只有一个线程可以在写模式下拥有这个锁。当读写锁在读模式下时，只要线程先获取了读模式下的读写锁，该锁保护的数据就可以被多个获得读模式的线程读取。
读写锁也叫共享互斥锁（shared-exclisive lock）。当读写锁是读模式锁住时，就可以说成是共享模式锁住的。当它是写模式锁住时就可以说成是互斥模式锁住的。
与互斥量相比，读写锁在使用之前必须初始化，在释放它们的底层内存之前必须销毁。

#include<pthread.h>
int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock,const pthread_rwlockattr_t *restrict attr);    //默认属性为NULL
int pthread_rwlock_dstroy(pthread_rwlock_t *rwlock);

SUS 在XSI扩展中定义了PTHREAD_RWLOCK_INITIALIZER常量。如果默认属性就足够的话，可以用它对静态分配的读写锁进行初始化。

#include<pthread.h>
int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);//读模式锁定
int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);//写模式锁定
int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);//解锁

各种系统实现可能会对共享模式的读写锁有次数限制，所以要检查pthread_rwlock_rdlock的返回值进行检查。

#include<pthread.h>
int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock);
//可以获取锁时，这两个函数返回0，否则他们返回错误EBUSY。

11.6.5带有超时的读写锁

与互斥量一样，SUS提供了带有超时的读写锁加锁函数，使得应用程序在获取读写锁时避免陷入永久阻塞状态。

#include <pthread.h>
#include <time.h>
int pthread_rwlock_timedrdlock(pthread_rwlock_t *restrict rwlock,const struct timespec *restrict tsptr);
int pthread_rwlock_timedwrlock(pthread_rwlock_t *restrict rwlock,const struct timespec *restrict tsptr);

与pthreas_mutex_timedlock函数类似，超时时间是绝对时间，而不是相对时间。

11.6.6 条件变量

条件变量是线程可用的另一种同步机制。条件变量给多个线程提供了一个会合的场所。条件变量与互斥量一起使用时，允许线程以无竞争的方式等待特定的条件发生。
条件本身是由互斥量保护的。线程在改变条件状态之前必须首先锁住互斥量。其他线程在获得互斥量之前不会察觉到这种改变，因为互斥量必须在锁定以后才能计算条件。
在使用条件变量之前，必须先对它进行初始化。由pthread_cond_t数据类型表示的条件变量可以用两种方式进行初始化，可以把常量PTHREAD_COND_INITIALIZER赋给静态分配的条件变量，但是如果条件变量是动态分配的，则需要使用pthread_cond_init函数对它进行初始化。
在释放条件变量底层的内存空间之前，可以使用pthread_cond_destroy函数对条件变量进行反初始化（deinitialize）。

#include <pthread.h>
#include <time.h>
int pthread_cond_init(pthread_cond_t *restrict cond,const pthread_cond_t *restrict attr)；//属性可设为NULL
int pthread_cond_destroy(pthread_cond_t *cond)；

---

我们使用pthread_cond_wait等待条件变量变为真。如果在给定的时间内条件不能满足，那么会生成一个返回错误码的变量。

#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 tsptr)；

传递给pthread_cond_wait的互斥量对条件进行保护。

！！！！！！！！！！！！以下很重要！！！！！！！！！！！

调用者把锁住的互斥量（先外部上锁）传递给函数，函数然后自动把调用线程放到等待条件的线程表上，对互斥量解锁（再内部解锁）。这就关闭了条件检查和线程进入休眠状态等待条件改变这两个操作之间的时间通道（在条件检查和等待条件时不会错过信号，因为互斥量加锁了，所以信号发布出来），这样线程就不会错过条件的任何变化。 解锁之后函数就处于等待信号的状态，当信号到达时，pthread_cond_wait函数返回，互斥量再次被锁住（内部加锁），之后留给外部解锁。

#include <pthread>

struct msg{
struct msg *m_next;
};

struct msg *workg;

pthread_cont_t qready = PTHREAD_COND_INITIALIZER;
pthread_mutex_t qlock = PTHREAD_MUTEX_INITIALIZER;

void process_msg(void)
{
struct msg *mp;

for(;;)
{
pthread_mutex_lock(&qlock);
while(workq == NULL)
pthread_cond_wait(&qready,&qlock);
//线程在此阻塞，将线程保存到线程表后释放锁，开始等待条件变量；函数收到信号后返回，并加锁。
//收到信号后，此时workq已经不是NULL，所以继续向下执行。
mp = workq;
workq = mp->m_next;
pthread_mutex_unlock(&qlock);//这里对互斥锁解锁，表明同步完成。
}
}

void enqueue_msg(struct msg *mp)
{
pthread_mutex_lock(&qlock);//
mp->m_next = workq;
workq = mp;
pthread_mutex_unlock(&qlock);
pthread_cond_signal(&qready);//此处发送信号。
}

这里讲的比较清楚：
http://blog.csdn.net/hiflower/article/details/2195350
条件变量要和互斥量相联结，以避免出现条件竞争： 一个线程预备等待一个条件变量，当它在真正进入等待之前，另一个线程恰好触发了该条件。

11.6.7自旋锁

自旋锁与互斥量类似，但它不是通过休眠使进程阻塞，而是在获取锁之前一直处于忙等（自旋）阻塞状态。自旋锁可以用于以下情况：锁被持有的时间短，而且线程并不希望在重新调度上（不产生重新调度）花费太多的成本。
由于线程自旋等待的时候CPU不能做其他事情，因此自旋锁只能被持有一小段时间。
自旋锁用在非抢占式内核（）中时是非常有用的：除了提供互斥机制以外，它们会阻塞中断，这样中断处理程序就不会让系统陷入死锁状态，因为它需要获取已被加锁的自旋锁（把中断想成另一种抢占）。在这种类型的内核中，中断处理程序不能休眠（因为非抢占式内核不能休眠，因此不能使用互斥锁、读写锁、条件变量。），因此它们能用的同步原语只能是自旋锁。
很多互斥量的实现非常高效，以至于应用程序采用互斥锁的性能与曾经采用自旋锁的性能基本上是相同的。事实上，有些互斥量的实现在试图获取互斥量的时候会自旋一小段时间，只有在自旋计数达到某一阈值时才会休眠。这些因素再加上现代CPU的进步，使得上下文切换越来越快，也是的自旋锁在某些特定的情况下才有用。

---

自旋锁的接口与互斥量的接口类似，这使得它可以比较容易的从一个替换为另一个。

#include<pthread.h>
int pthread_spin_init(pthread_spin_t *lock,int pshared); 
int pthread_spin_dstroy(pthread_spin_t *lock);

pshared参数表示进程共享属性，表明自旋是如何获取的。只有在支持线程进程共享同步选项的平台上才有效。

• 设为PTHREAD_PROCESS_SHARED，则自旋锁能被底层内存的所有线程获取，即使那些线程属于不同的进程。
• 设为PTHREAD_PROCESS_private，则自旋锁就只能被初始化该锁的进程内部的线程所访问。

#include<pthread.h>
int pthread_spin_lock(pthread_spin_t *lock);
int pthread_spin_trylock(pthread_spin_t *lock);
int pthread_spin_unlock(pthread_spin_t *lock);

需要注意，不要调用在持有自旋锁的情况下可能会进入休眠状态的函数。如果调用了这些函数，会浪费CPU资源，因为其他线程需要获取自旋锁需要的时间就延长了。

11.6.8 屏障

屏障（barrier）是用户协调多个线程并行工作的同步机制。屏障允许每个线程等待，知道所有的合作线程都达到某一点，然后从该点继续执行。我们已经看到一种屏障pthread_join函数就是一种屏障，允许一个线程等待，知道另一个线程退出。
但屏障的概念更广，它允许任意数量的线程等待，直到所有的线程完成处理工作，而且线程不需要退出。所有线程达到屏障后可以接着工作。
使用pthread_barrier_init函数对屏障进行初始化，用pthread_barrier_destroy函数进行反初始化。

#include<pthread.h>
int pthread_barrier_init(pthread_barrier_t *restrict barrier,const pthread_barrierattr_t *restrict attr,unsigned int count); 
int pthread_barrier_dstroy(pthread_barrier_t *barrier);

• const参数指定，在允许所有线程继续运行之前，必须达到屏障的线程数目。
• attr参数指定屏障对象的属性
  可以使用pthread_barrier_wait 函数来表明，线程已经完成工作，准备等待所有其他线程赶上来。

#include<pthread.h>

int pthread_barrier_wait(pthread_barrier_t *barrier);

调用pthread_barrier_wait的线程在屏障计数未满足条件时，会进入休眠状态。如果该线程是最后一个调用pthread_barrier_wait的线程，就满足了屏障计数，所有的线程都被唤醒。

11.7 小结

本章介绍了线程的概念；
讨论了现有的创建和销毁线程的POSIX.1原语；
介绍了线程同步问题，讨论了5个基本的同步机制（互斥量、读写锁、条件变量、自旋锁以及屏障）。了解了如何使用它们来保护共享资源。