新手上路系列11：多线程编程

1、基本概念：

线程是进程的一个实体，是CPU调度和分派的基本单位，它是比进程更小的能独立运行的基本单位。线程自己基本上不拥有系统资源，只拥有一点在运行中必不可少的资源（如程序计数器，一组寄存器和栈），但是它可与同属于一个进程的其他的线程共享进程拥有的全部资源。在Linux 中有着成熟的库函数，需要使用pthread.h头文件，而且编译时需要加上 -lpthread。

2、线程的操作：

1）线程的创建：用到的函数为：pthread_create() ，它的参数很多（man pthread_create），其中需要特别提一下的是thread， 它是指向pthread_t类型的指针，用于引用新创建的线程。

2）线程参数的传递：需要用到一个结构体（使用时需要用void*强制类型转换）。另外，如果在函数内部建立线程，不能往外传参数，因为在栈上创建的变量会被释放。

3）线程等待与分离：int pthread_join、int pthread_detach 前者会处于阻塞状态，而后者不会，也不会导致所操作的线程结束，它只会在线程结束时清理其所占用的资源。对于创建时处于未分离状态的线程，必须调用一次pthread_join()或pthread_detach()，否则线程结束后就会留下没有释放的资源。 

4）线程终止：线程通过调用pthread_exit 函数终止执行，并返回一个指向某对象的指针。注意：绝不能用它返回一个指向局部变量的指针，因为线程调用结束后，这个局部变量就不存在了，这将引起严重的程序漏洞。调用pthread_exit()等价于在工作函数中执行return，区别是pthread_exit()可以在工作函数调用的任何函数中被调用。如果主线程调用pthread_exit()，而不是exit()或执行return，则其他线程将继续执行。

3、线程同步：当某个线程可以修改变量，而其他线程也可以读取或者修改这个变量的时候，就需要对这些线程进行同步，以确保它们在访问变量的存储内容时不会访问到无效的数值。线程同步的一些基本方式有下面几种：

1）信号量：信号量的操作包括创建（sem_init ），控制（sem_post(即v操作) 与sem_wait(即p操作) ）与销毁（sem_destroy ）。其中，sem_init 的第二个参数（int pshared）需要注意一下：pshared表明信号量是在一个进程的多个线程之间共享还是在多个进程之间共享。若pshared为0，信号量被一个进程的多个线程共享，此时应该将信号量(sem_t)置于所有线程可见的位置(全局变量或动态分配)。下面简单的实现一下多线程并发应用程序的一个经典模型：生产者与消费者模型。

系统中，产生消息的是生产者，处理消息的是消费者，消费者和生产者通过一个缓冲区进行消息传递。生产者产生消息后提交到缓冲区，然后通知消费者可以从中取出消息

进行处理。消费者处理完信息后，通知生产者可以继续提供消息。

#include <stdio.h>
#include <pthread.h>
#include <semaphore.h>
#include <time.h>
#include <string.h>

// 信号量和缓冲区
struct data
{
	sem_t empty;  // 用来控制生产者，只有缓冲区为空，生产者才可以生产消息
	sem_t full;   // 用来控制消费者，只有缓冲区有数据，才可以消费
	char buf[32]; // 消息缓冲区
};

struct data msg;

// 生产者线程工作函数
void *Produce(void *v)
{
	char *buf[] = {"苹果", "梨", "香蕉", "榴莲", "橙子", "西瓜", "芒果", "火龙果"};
	
	while (1)
	{
		// 只有当缓冲区空才能进，生产消息
		sem_wait(&msg.empty);
		
		strcpy(msg.buf, buf[rand()%8]);
		printf ("放了一个水果： %s\n", msg.buf);

		int time = rand() % 100 + 1;
		usleep(time*10000);		
		
		// 生产完了，通知消费者进行消费
		sem_post(&msg.full);
	}
}

// 消费者线程工作函数
void *Consum(void *v)
{
	char  buf[32];
	while (1)
	{
		// 只有当缓冲区不为空才能进，消费消息
		sem_wait(&msg.full);
		
		strcpy(buf, msg.buf);
		printf ("吃了一个  %s\n", buf);
		
		int time = rand() % 100 + 1;
		usleep(time*10000);
		
		// 消费完了，通知生产则会进行生产
		sem_post(&msg.empty);
	}
}

int main()
{
	srand ((unsigned int)time(NULL));
	
	// 初始化信号量
	sem_init(&msg.empty, 0, 1);  // 生产者，一开始要生产消息
	sem_init(&msg.full, 0, 0);   // 消费者，一开始要不能消费消息

	pthread_t produceId;
	pthread_t consumId;
	// 创建生产者线程
	pthread_create(&produceId, NULL, Produce, NULL);
	
	// 创建消费者线程
	pthread_create(&consumId, NULL, Consum, NULL);
	
	// 等待线程结束
	pthread_join(produceId, NULL);
	pthread_join(consumId, NULL);
	
	// 销毁信号量
	sem_destroy(&msg.empty);
	sem_destroy(&msg.full);
	return 0;
}

2）互斥量：初始化（pthread_mutex_t），操作函数（pthread_mutex_lock与pthread_mutex_unlock）与销毁（pthread_mutex_destroy）。有了互斥量的加入，我们就可以对上面的程序进行一些改进，如果将缓冲区设计为一个先进先出的队列，可以同时容纳多条消息，那么只要缓冲区不满，生产者就可以提交消息。

// 生产者线程工作函数
void *Produce(void *v)
{	
	while (1)
	{
		int time = rand() % 100 + 1;
		usleep(time*10000);

		// 只要队列不满 就能生产消息， empty代表当前队列剩余的空间
		sem_wait(&msg.empty);
		pthread_mutex_lock(&mutex);    // 抢锁
		
		num++;   // 生产一个消息
  		
		// 将消息放入到队列里面
		EnQueue (&(msg.q), num);
		printf ("生产一条消息\n");
		
		pthread_mutex_unlock(&mutex);  // 解锁
		// 生产完了，通知消费者进行消费
		sem_post(&msg.full);
	}
}

加上一个抢锁和解锁的过程。

// 消费者线程工作函数
void *Consum(void *v)
{
	char  buf[32];
	while (1)
	{
		int time = rand() % 100 + 1;
		usleep(time*10000);
		
		// 只有缓冲区有数据，就能消费消息， full当前队列消息的个数
		sem_wait(&msg.full);
		pthread_mutex_lock(&mutex);    // 抢锁
		
		int num;
		DeQueue(&(msg.q), &num);   // 去队列里取出一条消息
		printf("消费了一条消息: %d\n", num);
		
		pthread_mutex_unlock(&mutex);  // 解锁
		// 消费完了，通知生产则会进行生产
		sem_post(&msg.empty);
	}
}

3）条件变量：当线程不满足某些条件时，进图睡眠，而满足后再被唤醒。

用到的函数有：初始化( pthread_cond_init )、沉睡( pthread_cond_wait )、唤醒( pthread_cond_broadcast )。

再加上条件变量的知识，上面的程序又能进一步改进：

// 互斥锁
pthread_mutex_t mutex;

// 条件变量
pthread_cond_t cond;

// 共享资源
int num = 0;

// 生产者线程工作函数
void *Produce(void *v)
{	
	while (1)
	{
		int time = rand() % 100 + 1;
		usleep(time*10000);
		pthread_mutex_lock(&mutex);    // 抢锁
		
		printf ("生产资源\n");

		num += 2;
		
		// 唤醒所有在条件变量 cond 上进行等待的线程
		pthread_cond_broadcast(&cond);
		pthread_mutex_unlock(&mutex);  // 解锁
	}
}

加上了沉睡和唤醒的步骤能节约大量资源：

// 消费者线程工作函数
void *Consum(void *v)
{
	while (1)
	{
		int time = rand() % 100 + 1;
		usleep(time*10000);
		pthread_mutex_lock(&mutex);    // 抢锁
	
		while (num == 0)
		{
			// 陷入沉睡， 等待某个人条件变量满足
			// 第一个参数是等待哪个条件变量，第二个参数是相关的互斥锁
			// 一旦 进行 条件等待，会陷入沉睡，让出CPU资源，阻塞在当前位置
			// 工作步骤：
			// 1、解锁互斥锁，让其他线程可以抢夺这个锁
			// 2、当被唤醒的时候，和所有在互斥锁上阻塞的线程一起抢夺锁，抢到就继续执行，抢不到 继续抢
			
			// 外层需要有一个循环，判断当前条件是否满足，因为就算该线程被唤醒，num 也不一定就是一个大于 0 的数
			pthread_cond_wait(&cond, &mutex);
		}
		
		num--;
		printf ("消费一个消息， 剩余资源： %d\n", num);
	
		
		pthread_mutex_unlock(&mutex);  // 解锁
	}
}