线程

线程标识

线程ID只在它所属的进程环境中有效。

pthread_equal用来对比两个线程ID。

int pthread_equal(pthread_t tid1, pthread_t tid2);

pthread_self用来获得自身的线程ID。

pthread_t pthread_self(void);

pthread_create用来创建线程

int pthread_create(pthread_t *restrict tidp, const pthread_attr_t *restrict attr, void *(*start_rtn)(void *), void *restrict arg);

tidp被设置为线程ID，attr用于定制各种不同的线程属性，新创建的线程从start_rtn开始运行，arg为start_rtn的参数。

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

调用pthread_create失败时通常会返回错误码，该错误码是errno的副本，可以兼容errno的现有函数。

pthread_exit用来终止线程

void pthread_exit(void *rval_ptr);

rval_ptr是一个无类型指针，与传给启动例程的单个参数类似。进程中的其他线程可以通过调用pthread_join函数访问到这个指针。

int pthread_join(pthread_t thread, void **rval_ptr);

调用线程将一直阻塞，直到指定的线程调用pthread_exit、从启动例程中返回或者取消。如果线程只是从它的启动例程返回，rval_ptr将包含返回码。如果线程被取消，由rval_ptr指定的内存单元就置为PTHREAD_CANCELED。

可以通过调用pthread_join自动把线程置于分离状态，这样资源就可以恢复。如果线程已经处于分离状态，pthread_join调用就会失败，返回EINVAL。

如果对线程的返回值不感兴趣，可以把rval_ptr置为NULL。

如果线程已经处于分离状态，线程的底层存储资源可以在线程终止时立即被收回。当线程被分离时，并不能用pthread_join函数等待它的终止状态。对分离状态的线程进行pthread_join的调用会产生失败，返回EINVAL。

pthread_detach调用可以用于使线程进入分离状态。

int pthread_detach(pthread_t tid);

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

int pthread_cancel(pthread_t tid);

在默认的情况下，pthread_cancel函数会使得由tid标识的线程的行为表现为如同调用了参数为PTHREAD_CANCELED的pthread_exit函数，但是，线程可以选择忽略取消方式或是控制取消方式。

线程可以安排它退出时需要调用的函数，这样的函数称为线程清理处理程序。线程可以建立多个清理处理程序。

void pthread_cleanup_push(void (*rtn)(void *), void *arg);

void pthread_cleanup_pop(int execute);

当线程执行以下动作时调用清理函数，调用参数为arg：

（1）调用pthread_exit时。

（2）响应取消请求时。

（3）用非零execute参数调用pthread_cleanup_pop时。

如果execute参数置为0，清理函数将不被调用。无论哪种情况，pop都将删除上次push调用建立的清理处理程序。

线程同步

互斥量

互斥量的初始化和销毁动态分配的互斥量。

int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);

int pthread_mutex_destroy(pthread_mutex_t *mutex);

对互斥量加锁、尝试加锁、解锁

int pthread_mutex_lock(pthread_mutex_t *mutex);

inint pthread_mutex_trylock(pthread_mutex_t *mutex);

int pthread_mutex_unlock(pthread_mutex_t *mutex);

如果调用pthread_mutex_trylock时互斥量处于未锁住状态，那么pthrea_mutex_trylock将锁住互斥量，不会出现阻塞并返回0，否则就会失败，返回EBUSY.

读写锁

一次只有一个线程可以占有写模式的读写锁，但是多个线程可以同时占有读模式的读写锁。

当读写锁处于读模式锁住状态时，如果有另外的线程试图以写模式加锁，读写锁通常会阻塞随后的读模式锁请求。这样可以避免读模式锁长期占用，而等待的写模式锁请求一直得不到满足。

读写锁的初始化和销毁动态分配的读写锁。

int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock, const pthread_rwlockattr_t *restrict attr);

int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);

要在读模式下锁定读写锁，需要调用pthread_rwlock_rdlock；要在写模式下锁定读写锁，需要调用pthread_rwlock_wrlock。

int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);

int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);

int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);

条件变量

条件本身是由互斥量保护的。线程在改变条件状态前必须首先锁住互斥量，其他线程在获得互斥量之前不会察觉到这种改变，因为必须锁定互斥量以后才能计算条件。

条件变量的初始化和销毁动态分配的条件变量。

int pthread_cond_init(pthread_cond_t *restrict cond, pthread_condattr_t *restrict attr);

int pthread_cond_destroy(pthread_cond_t *cond);

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

int pthread_cond_wait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex);

int pthread_cond_timedwait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex, const struct timespec *restrict timeout);

传递给pthread_cond_wait的互斥量对条件进行保护，调用者把锁住的互斥量传给函数。函数把调用线程放到等待条件的线程列表上，然后对互斥量解锁，这两个操作时原子操作。

这样就关闭了条件检查和线程进入休眠状态等待条件改变这两个操作之间的时间通道，这样线程就不会错过条件的任何变化。pthread_cond_wait返回时，互斥量再次被锁住。

从pthread_cond_wait或者pthread_cond_timedwait调用成功返回时，线程需要重新计算条件，因为其他的线程可能已经在运行并改变了条件。

pthread_cond_signal可以唤醒等待条件的某个线程，而pthread_cond_broadcast将唤醒等待条件的所有线程。

int pthread_cond_signal(pthread_cond_t *cond);

int pthread_cond_broadcast(pthread_cond_t *cond);

条件变量的使用
#include <pthread.h>
struct msg {
    struct msg *m_next;
    /*....*/
}
struct msg *workq;
pthread_cond_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);
        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);
}