我们前面讨论了进程，知道了unix的进程环境，进程之间的关系以及控制进程的方法。我们可以看到，进程间可以进程有限的共享。

本章，我们将会深入到进程的内部，来看看我们如何在单进程环境中使用多线程控制。所有同一个进程中的线程都可以共享访问例如文件描述符号，内存等进程资源。

任何时候，你想要在多个用户之间共享单个资源的时候，你都需要处理一致性的问题。我们后面引入了线程的同步机制，防止在它们之间出现共享的资源不一致的情况。

一个典型的UNIX进程，可以被认为是单线程控制的：每个进程每个时刻只做一件事情。在多线程控制中，我们可以让自己的程序每次做更多的事情，每个线程处理一个任务，这样的方法有许多的好处：

a) 我们可以通过指定一个线程来处理每个事件，来简化对异步事件处理的代码。每个线程之后可以使用一个同步的编程模型来处理它的事件。同步编程模型要比异步简单的多。 b) 多进程需要使用操作系统提供的复杂的机制来共享内存和文件描述符号。而多线程的化，可以直接访问同一个进程中的同一个内存地址和文件描述符号。 c) 有些问题可以被分割，这样整体的程序吞吐量会提升。而单个进程处理多个任务的话会隐式地将这些任务串行化，因为只有一个线程控制。在多线程控制中，每个线程可以处理独立的任务，独立的任务可以交叉地执行，所谓独立的任务就是它们之间不会相互依赖。 d) 类似地，交互程序通过使用多线程技术，可以提升用户的响应时间，主要是把和用户输入输出交互的部分和程序的其它部分别用不同的线程处理。

有些用户把多线程和多处理器联系起来。实际多线程带来的好处即使是在单个的cpu系统中也是存在的。一个程序可以通过多线程被简化，而不必考虑处理器的数目，因为处理器的数目不会影响程序的结构。另外，只要你的程序在串行任务中被阻塞，你就可能可以通过多线程提高程序吞吐，因为线程在其它线程阻塞的时候还是可以运行的。

在进程中，一个线程包含了代表一个执行单元的必要的信息，这些信息包含：线程 ID （用来标识一个进程中的线程），一系列寄存器的值，一个堆栈，调度优先级和策略，一个 signal mask ,和 errno 变量，还有线程相关的数据。所有在一个进程中的东西在线程中都是可以被共享的，包含程序的可执行代码，程序的全局变量和堆内存，堆栈，和文件描述符号。

我们将要看的线程接口来自 POSIX.1-2001 .这些线程的接口也被称作 pthreads （ POSIX threads ），是 POSIX.1-2001 中的一个可选的部分。这个特性，可以使用 _POSIX_THREADS 宏来进行测试。应用程序可以在编译的时候使用 #ifdef 来测试是否支持线程，也可以在运行的时候使用 sysconf 的 _SC_THREADS 常量来确定是否支持线程。

就像每个进程都有一个进程 ID ，每个线程都有线程 ID 。和进程 ID 不一样，进程 ID 在系统中是唯一的；线程 ID 只有在它所在的进程的上下文中才有意义。

需要记住的是，进程 ID 使用 pid_t 类型来表示，并且它是一个非负的整数。线程 ID 用 pthread_t 数据类型来代替，有些实现允许使用一个数据结构来代表 pthread_t 数据类型，所以可移植的实现不允许把它们做为整数来看待。所以有一个专门用来比较 thread ID 的函数。

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

返回：如果相等返回非0，如果不等返回0。

Linux2.4.22 使用无符号长整数代表 pthread_t 数据类型。 Solaris 9 使用 pthread_t 数据类型是 unsigned int . FreeBSD 5.2.1 和 Mac OS X 10.3 使用一个指向 pthread 数据结构的指针来表示 pthread_t 数据类型。

允许 pthread_t 数据类型是一个结构，这样会导致无法使用一个比较容易移植的方法来打印它的值。有时，在调试程序的时候打印线程 ID 是很重要的，但是其他时候，一般来说也没有必要非得这么做.最差的时候，会得到一个不可移植的调试程序的代码，所以这也不是一个不能接受的限制。

线程可以通过调用 thread_self 函数来获得它自己的线程 ID 。

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

返回：调用线程的 thread ID 。

这个函数可以和 pthread_equal 一块使用，来辨别一个数据结构是否是它自己的 thread ID .例如一个主线程可能会把工作分配到一个队列上面，使用 thread ID 来判断那个作业被那个工作线程处理。

这里给出了一个图示，展示工作队列：

                               +--------+
                               | master |
                              /| thread |
                             / +--------+
   +-------+                v
   |thread1|<----\  +------+
   +-------+      \ |      |     +------+     +------+     +------+     +------+
                   \|      |     | TID1 |     | TID3 |     | TID2 |     | TID3 |
+-------+           | work |     +------+     +------+     +------+     +------+
|thread2|<----------|queue |<--->|      |<--->|      |<--->|      |<--->|      |
+-------+           |      |     | job  |     | job  |     | job  |     | job  |
                   /|      |     |      |     |      |     |      |     |      |
   +-------+      / |      |     +------+     +------+     +------+     +------+
   |thread3|<----/  +------+
   +-------+

图示中，一个单个的主线程将新的作业放到工作队列中，有三个工作线程会把作业从队列中移走。为了可以让每个线程处理队头的作业，主线程在每个作业结构中添加了一个thread ID成员来表示应该处理这个作业的线程，每个线程只会从工作队列中移走它对应的线程ID的工作。

传统的 unix 进程模型，只支持每个进程只有一个线程控制。在概念上来说，这和基于线程模型的只有一个线程的进程是一样的。使用 pthreads ,当一个程序运行的时候，它会启动一个只有一个线程的进程，程序运行的时候，如果它不创建新的线程，那么它和传统的 unix 进程运行没有什么两样.通过 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 用来自定义各种线程属性，后面会讲到，这里设置为 NULL 表示采用默认的属性.

新创建的线程从 start_rtn 函数指针指向的地址开始运行， arg 是传递给这个函数的参数，它是一个无类型的指针，如果想要给函数传递多个参数那么就将参数存放在一个结构体中，把结构体的地址赋给 arg .

当一个线程创建的时候，无法确保是调用线程先运行还是新创建的线程先运行。新创建的线程可以访问进程空间地址，继承调用线程的 floating-point 环境和 signal mask ,然而被 pending 的信号会被清除。

注意，线程函数失败的时候会返回一个错误码。它不象其他会设置 errno 变量，为每个线程提供错误码，只是为了兼容使用它们的函数.对于线程来说，从函数中返回错误码是很清晰的做法，这样把错误的范围就只限定在产生这个错误的函数的身上了,而不是通过修改一个全局性质的变量，使得这个函数具有一些副作用。

举例：尽管没有一个打印线程ID的可移植的方法，我们可以自己写一个小的测试程序来实现它，这样可以看到一些线程是如何工作的信息。后面的程序就是创建了一个线程，然后打印进程 ID ,主线程 ID ,以及新创建的线程 ID .

为了处理主线程和新线程之间的竞争，这个例子有两个比较奇怪的行为：

1）主线程需要睡眠一会。如果主线程不睡眠，那么可能在新创建的线程还没有来得及运行的时候主线程就结束了，进而导致整个进程的退出。这个取决于系统的线程功能实现以及调度算法。
2）新线程是通过pthread_self来获取自己的线程id。新线程不是通过读取共享的内存或者pthread_create的参数(tidp)来获得它的线程id的，因为这样不安全。如果这样使用，那么新创建的线程若先运行的话，那么调用线程还没有来得及初始化这些数据，就会被新线程使用了。

对于这个例子，具体的代码参见参考资料，我们看到的现象是：

Solaris中，两个线程的进程id相等，线程id是两个整数。主线程比新线程先运行。
FreeBSD中，两个线程的进程id相等，线程id是两个相差范围不大的地址。主线程比新线程先运行。
MacOS X中，两个线程的进程id相等，线程id是两个相差范围很大的地址。主线程比新线程先运行。
Linux中，两个线程的进程id不相等，线程id是两个整数。新线程比主线程先运行。
Linux中两个线程的进程id不相等，这是个不足的地方,它是使用特殊参数的clone系统调用来创建子进程，子进程可以通过参数配置共享父进程哪些上下文环境，例如文件描述符号或者内存。

注意这个例子的现象中我们可以看到，除了linux之外，其他的系统都是主线程先运行。这样我们可以知道我们不能随意假设主线程或者新线程究竟哪个首先被运行。

当进程的任何一个线程调用 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_prt 将会包含相应的返回码;如果线程被取消， rval_ptr 指向的内存地址将会被设置为 PTHREAD_CANCELED .

调用 pthread_join 会自动地把线程置于 detached 状态，以便恢复线程的资源（稍后会讲到）。如果线程已经是 detached 状态了，那么 pthread_join 会失败并且返回 EINVAL.

如果我们对线程的返回值不感兴趣，那么我们可以把rval_ptr设置为空，这样会等待指定的线程但是不获取线程的退出状态。

举例

void *thr_fn1(void *arg)
{
    printf("thread 1 returning\n");
    return((void *)1);
}
void *thr_fn2(void *arg)
{
    printf("thread 2 exiting\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)
        err_quit("can't create thread 1: %s\n", strerror(err));//一个出了错就退出程序的函数.
    err = pthread_create(&tid2, NULL, thr_fn2, NULL);
    if (err != 0)
        err_quit("can't create thread 2: %s\n", strerror(err));
    err = pthread_join(tid1, &tret);
    if (err != 0)
        err_quit("can't join with thread 1: %s\n", strerror(err));
    printf("thread 1 exit code %d\n", (int)tret);
    err = pthread_join(tid2, &tret);
    if (err != 0)
        err_quit("can't join with thread 2: %s\n", strerror(err));
    printf("thread 2 exit code %d\n", (int)tret);
    exit(0);
}

运行如下：

$ ./a.out
  thread 1 returning
  thread 2 exiting
  thread 1 exit code 1
  thread 2 exit code 2

可以看出，一个线程如果从 start 函数中退出，或者调用 pthread_exit 退出，那么其他的进程可以通过 pthread_join 来获取进程的结束状态。

我们可以给 pthread_create 和 pthread_exit 传递一个无类型的指针，这样指针可以指向复杂的结构，包含更多得信息。需要注意的是当线程结束的时候，指针指向的位置应该还是合法的。如果指针指向的位置是在栈上面分配的，那么当线程结束之后，栈内容就不确定了。而调用 pthread_join 的调用者却使用了刚才栈所在地址的内容。

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

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

返回值：0表示成功，错误码表示失败。

默认情况下 pthread_cancel 调用会导致 tid 指定的线程表现的像是自己调用具有 PTHREAD_CANCELED 参数的 pthread_exit 一样。线程也可以选择忽略其他线程对它的取消，以及选择如何被取消以后会讲到。然而 pthread_cancel 不会等待线程结束，它只是做一个请求。

线程可以设置退出时候调用的函数，这个和进程使用 atexit 函数设置进程退出时候调用得函数类似。这些函数叫做“线程清理函数”，可以为线程设置多个清理函数，这些清理函数被记录在栈中，这也意味这这些函数的调用次序和它们被注册的次序相反。

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

当线程执行如下动作的时候， pthread_cleanup_push 会调度清理函数，函数由 rtn 指向并且参数是 arg :

1. 调用 pthread_exit
2. 响应取消请求
3. 使用非0的 execute 参数调用 pthread_cleanup_pop .

当 pthread_cleanup_pop 参数为0的时候，不会调用清理函数，这个时候会把最后一次调用 pthread_cleanup_push 的函数去掉。

这些函数的使用限制就是它们是使用宏实现的，它们必须在一个线程的同一个作用域内成对匹配使用， pthread_cleanup_push 宏包含是一个 { , pthread_cleanup_pop 宏包含一个 } 。

举例：

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");
    if (arg)
        return((void *)1);
    pthread_cleanup_pop(0);
    pthread_cleanup_pop(0);
    return((void *)1);
}

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");
    if (arg)
        pthread_exit((void *)2);
    pthread_cleanup_pop(0);
    pthread_cleanup_pop(0);
    pthread_exit((void *)2);
}

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

    err = pthread_create(&tid1, NULL, thr_fn1, (void *)1);
    if (err != 0)
        err_quit("can't create thread 1: %s\n", strerror(err));
    err = pthread_create(&tid2, NULL, thr_fn2, (void *)1);
    if (err != 0)
        err_quit("can't create thread 2: %s\n", strerror(err));
    err = pthread_join(tid1, &tret);
      if (err != 0)
        err_quit("can't join with thread 1: %s\n", strerror(err));
    printf("thread 1 exit code %d\n", (int)tret);
    err = pthread_join(tid2, &tret);
    if (err != 0)
        err_quit("can't join with thread 2: %s\n", strerror(err));
    printf("thread 2 exit code %d\n", (int)tret);
    exit(0);
}

上面的例子展示了如何使用线程的清理函数。需要注意的是尽管我们没有打算给线程的启动函数传递非0参数，我们还是需要调用 pthread_cleanup_pop 函数来匹配 pthread_cleanup_push 函数，否则程序无法编译通过。

运行这个程序的输出是：

$ ./a.out
thread 1 start
thread 1 push complete
thread 2 start
thread 2 push complete
cleanup: thread 2 second handler
cleanup: thread 2 first handler
thread 1 exit code 1
thread 2 exit code 2

从输出中我们可以看到，两个线程都正常地启动和退出了，但是只有第二个线程调用了清理函数。因此，如果线程是通过从启动函数中正常返回而终止的话，就不会执行清理函数。并且我们也应该注意启动函数的调用次序和它们被安装的次序是相反的。

实际线程和进程有许多类似的函数，下表给出了这个对比。

进程和线程相关函数的对比

+-------------------------------------------------------------------------------------------------------+
| Process primitive |  Thread primitive   |                         Description                         |
|-------------------+---------------------+-------------------------------------------------------------|
| fork              | pthread_create      | create a new flow of control                                |
|-------------------+---------------------+-------------------------------------------------------------|
| exit              | pthread_exit        | exit from an existing flow of control                       |
|-------------------+---------------------+-------------------------------------------------------------|
| waitpid           | pthread_join        | get exit status from flow of control                        |
|-------------------+---------------------+-------------------------------------------------------------|
| atexit            | pthread_cancel_push | register function to be called at exit from flow of control |
|-------------------+---------------------+-------------------------------------------------------------|
| getpid            | pthread_self        | get ID for flow of control                                  |
|-------------------+---------------------+-------------------------------------------------------------|
| abort             | pthread_cancel      | request abnormal termination of flow of control             |
+-------------------------------------------------------------------------------------------------------+

默认来说，一个线程的终止状态会一直保留到 pthread_join 被调用。一个终止的线程所占的内存会在 detached 的时候立即被回收，当一个线程被 detached 的时候，不能使用 pthread_join 函数等待获取它的终止状态。对一个 detached 的线程调用 pthread_join 会失败，并且返回 EINVAL 。我们可以使用 pthread_detach 来将一个线程 detach .

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

返回：如果成功返回0，如果失败返回错误编号。 后面我们可以看到，我们可以通过修改传递给 pthread_create 的线程属性参数来建立一个开始就处于 detached 状态的线程。

当多个线程共享同一片内存的时候，我们需要保证每个线程看到的数据是一致的。如果线程使用的变量没有被其他线程使用，那么不会存在一致性的问题。类似，如果一个变量是只读，那么多个线程同时访问也不会出现一致性的问题。然而当有一个线程可以修改这个变量，而这个变量同时也可以被其他的线程修改和读取的时候，我们需要在线程之间进行同步，来保证它们访问变量内存的内容的时候的数据是合法的。

当一个线程修改变量的时候，别的读取这个变量的线程会潜在地遭遇不一致的情况。在修改操作占用多于一个存储周期的处理器架构上面，这个情况在两次写周期之间进行读内存的时候很容易发生。虽然这个取决于处理器架构，但是一个可移植的程序不能对使用的处理器的架构做任何的假设。

文中先给出了一个简单的情况:

线程A:读－写－写
线程B:-----读----

当B的读发生在A的两个写周期之间的时候，A，B就存在不一致性的问题了。

图中先给了一个解决方案：规定在访问变量之前，先对变量进行加锁。这样当一进程持有锁的时候，其它申请锁将被阻塞。

然后又给出了一些其它导致不一致的情况的例子，具体参见参考资料以及其中的图示。

这一章里面我们介绍了线程相关的内容，讨论了创建和销毁一个线程的POSIX相关函数。我们也介绍了线程的同步。我们讨论了三个基本的同步机制，互斥信号量，读写锁，以及条件变量，同时我们也看到了我们是如何利用它们来保护共享资源的。