1 线程安全

多线程编程环境中，多个线程同时调用某些函数可能会产生错误结果，这些函数称为非线程安全函数。如果库函数能够在多个线程中同时执行并且不会互相干扰，那么这个库函数就是线程安全（ thread-safe）函数 。

2 互斥量

2.1 临界区

2.2 什么是互斥量

互斥量（ Mutex）， 又称为互斥锁， 是一种用来保护临界区的特殊变量， 它可以处于锁定（ locked） 状态， 也可以处于解锁（ unlocked） 状态：

• 如果互斥锁是锁定的， 就是一个特定的线程持有这个互斥锁；
• 如果没有线程持有这个互斥锁，那么这个互斥锁就处于解锁状态。

互斥量是最简单也是最有效的线程同步机制。程序可以用它来保护临界区，以获得对排它性资源的访问权。另外，互斥量只能被短时间地持有，使用完临界资源后应立即释放锁。

2.3 创建与销毁

2.3.1 创建互斥量

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

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

int error;
pthread_mutex_t mylock;
if (error = pthread_mutex_init(&mylock, NULL))
    fprintf(stderr, "Failed to initialize mylock : %s\n", strerror(error));

2.3.2 销毁互斥量

int pthread_mutex_destroy(pthread_mutex_t *mutex);

int error;
pthread_mutex_t mylock;
if (error = pthread_mutex_destroy(&mylock))
    fprintf(stderr, "Failed to destroy mylock : %s\n", strerror(error));

2.4 加锁与解锁

2.4.1 加锁

线程试图锁定互斥量的过程称之为加锁。
Pthreads 中有两个试图锁定互斥量的函数， pthread_mutex_lock()和 pthread_mutex_trylock()。pthread_mutex_lock()函数会一直阻塞到互斥量可用为止，而 pthread_mutex_trylock()会尝试加锁，通常立即返回。函数原型如下：

int pthread_mutex_lock (pthread_mutex_t *mutex);
int pthread_mutex_trylock (pthread_mutex_t *mutex);

2.4.2 解锁

解锁是线程将互斥量由锁定状态变为解锁状态。
pthread_mutex_unlock()函数用来释放指定的互斥量。函数原型如下：

int pthread_mutex_unlock (pthread_mutex_t *mutex);

pthread_mutex_t mylock = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_lock(&mylock);
...临界区代码省略...
pthread_mutex_unlock(&mylock);

2.4.3 线程范例

使用互斥量保护多线程同时输出
#include<stdio.h>
#include<string.h>
#include<pthread.h>
#include<stdlib.h>
#include<unistd.h>

pthread_t tid[2];
pthread_mutex_t lock;

void* doPrint(void *arg)
{
	int id = (long)arg;
	int i = 0;
	 
	pthread_mutex_lock(&lock); /* 使用互斥量保护临界区 */
	printf("Job %d started\n", id);
	for (i = 0; i < 5; i++) 
	{
		printf("Job %d printing\n", id);
		usleep(10);
	}
	printf("Job %d finished\n", id);
	pthread_mutex_unlock(&lock);
	return NULL;
}

int main(void)
{
	long i = 0;
	int err;

	if (pthread_mutex_init(&lock, NULL) != 0) /* 动态初始化互斥量 */
	{
		printf("\n Mutex init failed\n");
		return 1;
	}
	
	while(i < 2)
	{
		err = pthread_create(&(tid[i]), NULL, &doPrint, (void*)i);
		if (err != 0)
		printf("Can't create thread :[%s]", strerror(err));
		i++;
	}
	
	pthread_join(tid[0], NULL);
	pthread_join(tid[1], NULL);
	pthread_mutex_destroy(&lock);

	return 0;
}

下图是将上面程序清单中修改为不使用互斥量（注释第 14 和 21 行）的输出，可见输出为乱序。

2.5 死锁和避免

2.5.1 什么是死锁

死锁是指两个或两个以上的执行序在执行过程中， 因争夺资源而造成的一种互相等待的现象。例如： 一个线程 T1 已锁定了一个资源 R1， 又想去锁定资源 R2，而此时另一个线程 T2 已锁定了资源 R2，却想去锁定资源R1，两个线程都想得到对方的资源，而不愿释放自己的资源，造成两个线程都在等待，而无法执行的情况，如下图所示。

下面程序清单示例了死锁发生的情况，程序创建了两个线程，第一个线程先获取 mutexA锁，再获取 mutexB 锁；第二个线程先获取 mutexB 后获取 mutexA，这时死锁就可能发生。

死锁产生的范例
#include<stdio.h>
#include<string.h>
#include<pthread.h>
#include<stdlib.h>
#include<unistd.h>

pthread_t tid[2];
pthread_mutex_t mutexA = PTHREAD_MUTEX_INITIALIZER; /* 静态初始化互斥量 */
pthread_mutex_t mutexB = PTHREAD_MUTEX_INITIALIZER;

void * t1(void *arg) {
	pthread_mutex_lock(&mutexA); /* 线程 1 获取 mutexA */
	printf("t1 get mutexA\n");
	usleep(1000);
	pthread_mutex_lock(&mutexB); /* 线程 1 获取 mutexB */
	printf("t1 get mutexB\n");
	pthread_mutex_unlock(&mutexB); /* 线程 1 释放 mutexB */
	printf("t1 release mutexB\n");
	pthread_mutex_unlock(&mutexA); /* 线程 1 释放 mutexA */
	printf("t1 release mutexA\n");
	return NULL;
}

void * t2(void *arg) {
	pthread_mutex_lock(&mutexB);
	printf("t2 get mutexB\n");
	usleep(1000);
	pthread_mutex_lock(&mutexA);
	printf("t2 get mutexA\n");
	pthread_mutex_unlock(&mutexA);
	printf("t2 release mutexA\n");
	pthread_mutex_unlock(&mutexB);
	printf("t2 release mutexB\n");
	return NULL;
}

int main(void) {
	int err;
	err = pthread_create(&(tid[0]), NULL, &t1, NULL ); /* 创建线程 1 */
	
	if (err != 0)
		printf("Can't create thread :[%s]", strerror(err));
	err = pthread_create(&(tid[1]), NULL, &t2, NULL); /* 创建线程 2 */
	
	if (err != 0)
		printf("Can't create thread :[%s]", strerror(err));
	
	pthread_join(tid[0], NULL);
	pthread_join(tid[1], NULL);
	return 0;
}

下图为程序清单的运行结果， t1 线程获取 mutexA 后等待 mutexB， t2 线程获取mutexB 后等待 mutexA，两个线程互相等待，进入死锁。

                        

2.5.1 死锁的避免

t1                         t2                         t3
lock(mutexA)         lock(mutexA)                  lock(mutexB)
lock(mutexB)         lock(mutexC)                  lock(mutexC)
lock(mutexC)

3 条件变量

3.1 为什么需要条件变量 

在多线程编程中仅使用互斥锁来完成互斥是不够用的， 如以下情形：
假设有两个线程 t1 和 t2， 需要这个两个线程循环对一个共享变量 sum 进行自增操作，那么 t1 和 t2 只需要使用互斥量即可保证操作正确完成，线程执行代码如所示：

pthread_mutex_t sumlock= PTHREAD_MUTEX_INITIALIZER;
void * t1t2(void) {
    pthread_mutex_lock(&sumlock);
    sum++;
    pthread_mutex_unlock(&sumlock);
}

如果这时需要增加另一个线程 t3，需要 t3 在 count 大于 100 时将 count 值重新置 0 值，那么可以 t3 可以实现如下：

void * t3 (void) {
    pthread_mutex_lock(&sumlock);
    if (sum >= 100) {
        sum = 0;
        pthread_mutex_unlock(&sumlock);
    } else {
        pthread_mutex_unlock(&sumlock);
        usleep(100);
    }
}

3.2 创建与销毁

3.2.1 创建条件变量

Pthreads 用 pthread_cond_t 类型的变量来表示条件变量。程序必须在使用 pthread_cond_t 变量之前对其进行初始化。

（ 1） 静态初始化

对于静态分配的变量可以简单地将 PTHREAD_COND_INITIALIZER 赋值给变量来初始化默认行为的条件变量。

pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

（ 2）动态初始化

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

参数 cond 是一个指向需要初始化 pthread_cond_t 变量的指针，参数 attr 传递 NULL 值时， pthread_cond_init()将 cond 初始化为默认属性的条件变量。 

函数成功将返回 0；否则返回一个非 0 的错误码。

静态初始化程序通常比调用 pthread_cond_init()更有效，而且在任何线程开始执行之前，确保变量被执行一次。

以下代码示例了条件变量的初始化。

pthread_cond_t cond;
int error;
if (error = pthread_cond_init(&cond, NULL));
    fprintf(stderr, "Failed to initialize cond : %s\n", strerror(error));

int pthread_cond_destroy(pthread_cond_t *cond);

pthread_cond_t cond;
int error;
if (error = pthread_cond_destroy(&cond))
    fprintf(stderr, "Failed to destroy cond : %s\n", strerror(error));

3.3 等待与通知

3.3.1 等待

条件变量是与条件测试一起使用的，通常线程会对一个条件进行测试，如果条件不满足就会调用条件等待函数来等待条件满足。
条件等待函数有 pthread_cond_wait()pthread_cond_timedwait()和两个，函数原型如下：

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

    pthread_cond_wait()函数在条件不满足时将一直等待， 而 pthread_cond_timedwait()将只等待一段时间。 

参数 cond 是一个指向条件变量的指针，参数 mutex 是一个指向互斥量的指针，线程在调用前应该拥有这个互斥量，当线程要加入条件变量的等待队列时，等待操作会使线程释放这个互斥量。 pthread_timedwait()的第三个参数 abstime 是一个指向返回时间的指针，如果条件变量通知信号没有在此等待时间之前出现，等待将超时退出， abstime 是个绝对时间，而不是时间间隔。

以上函数成功调用返回 0，否则返回非 0 的错误码，其中 pthread_cond_timedwait（） 函数如果 abstime 指定的时间到期，错误码为 ETIMEOUT。

以下代码使得线程进入等待，直到收到通知并且满足 a 大于等于 b 的条件。

pthread_mutex_lock(&mutex)
while(a < b)
    pthread_cond_wait(&cond, &mutex)
pthread_mutex_unlock(&mutex)

3.3.2 通知

当另一个线程修改了某参数可能使得条件变量所关联的条件变成真时，它应该通知一个或者多个等待在条件变量等待队列中的线程。
条件通知函数有 pthread_cond_signal()和 pthread_cond_broadcast()函数，其中 pthread_cond_signal 函数可以唤醒一个在条件变量等待队列等待的线程，而 pthread_cond_broadcast函数可以所有在条件变量等待队列等待的线程。函数原型如下：

int pthread_cond_broadcast(pthread_cond_t *cond);
int pthread_cond_signal(pthread_cond_t *cond);

条件变量范例
#include<stdio.h>
#include<string.h>
#include<pthread.h>
#include<stdlib.h>
#include<unistd.h>

pthread_t tid[3];
int sum = 0;
pthread_mutex_t sumlock = PTHREAD_MUTEX_INITIALIZER; /* 静态初始化互斥量 */
pthread_cond_t cond_sum_ready = PTHREAD_COND_INITIALIZER; /* 静态初始化条件变量 */

void * t1t2(void *arg)
{
	int i;
	long id = (long)arg;
	
	for (i = 0; i < 60; i++) 
	{
		pthread_mutex_lock(&sumlock); /* 使用互斥量保护临界变量 */
		sum++;
		printf("t%ld: read sum value = %d\n", id + 1 , sum);
		pthread_mutex_unlock(&sumlock);
		if (sum >= 100)
			pthread_cond_signal(&cond_sum_ready); /* 发送条件通知，唤醒等待线程 */
	}
	return NULL;
}
void * t3(void *arg) 
{
	pthread_mutex_lock(&sumlock);
	while(sum < 100) /* 不满足条件将一直等待 */
	pthread_cond_wait(&cond_sum_ready, &sumlock); /* 等待条件满足 */
	sum = 0;
	printf("t3: clear sum value\n");
	pthread_mutex_unlock(&sumlock);
	return NULL;
}

int main(void) 
{
	int err;
	long i;
	for (i = 0; i < 2; i++) 
	{
		err = pthread_create(&(tid[i]), NULL, &t1t2, (void *)i); /* 创建线程 1 线程 2 */
		if (err != 0) 
		{
			printf("Can't create thread :[%s]", strerror(err));
		} 
	}
	err = pthread_create(&(tid[2]), NULL, &t3, NULL); /* 创建线程 3 */
	if (err != 0)
		printf("Can't create thread :[%s]", strerror(err));
	for (i = 0; i < 3; i++)
		pthread_join(tid[i], NULL);
	
	return 0;
}

上面程序清单的可能运行结果如下所示， sum 累加到 100 时发送条件通知，但程序结果中 sum 计算到 103 时， t3 才被调用，这是因为 signal 与 wait 调用之间有间隙存在。

t1: read sum value = 1
t1: read sum value = 2
...
t2: read sum value = 100
t1: read sum value = 101
t1: read sum value = 102
t1: read sum value = 103
t3: clear sum value
t2: read sum value = 1
.......
t2: read sum value = 17