Linux系统编程——线程

参考博文：Linux多线程编程初探

进程与线程

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

• 进程是程序执行时的一个实例，是担当分配系统资源（CPU时间、内存等）的基本单位。在面向线程设计的系统中，进程本身不是基本运行单位，而是线程的容器。程序本身只是指令、数据及其组织形式的描述，进程才是程序（那些指令和数据）的真正运行实例。

• 线程是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。线程包含了表示进程内执行环境必须的信息，其中包括进程中表示线程的线程ID、一组寄存器值、栈、调度优先级和策略、信号屏蔽字、errno常量以及线程私有数据。进程的所有信息对该进程的所有线程都是共享的，包括可执行的程序文本、程序的全局内存和堆内存、栈以及文件描述符。在Unix和类Unix操作系统中线程也被称为轻量级进程（lightweight processes），但轻量级进程更多指的是内核线程（kernel thread），而把用户线程（user thread）称为线程。

• 进程有独立的地址空间，一个进程崩溃后，在保护模式下不会对其它进程产生影响，而线程只是一个进程中的不同执行路径。线程有自己的堆栈和局部变量，但线程没有单独的地址空间，一个线程死掉就等于整个进程死掉，所以多进程的程序要比多线程的程序健壮，但在进程切换时，耗费资源较大，效率要差一些。但对于一些要求同时进行并且又要共享某些变量的并发操作，只能用线程，不能用进程。

“进程——资源分配的最小单位，线程——程序执行的最小单位（调度最小单位）”

• 线程又叫做轻量级进程（light-weight process LWP），也有PCB，创建线程使用的底层函数和进程底层一样，都是clone，但没有独立的地址空间，而进程有独立地址空间，拥有PCB。
• 主线程和子线程共享：
  • .text
  • .bss
  • .data
  • 堆
  • 动态加载区
  • 环境变量
  • 命令行参数
• 线程间通信：全局变量，堆
• 不共享： 若一共五个线程，栈区被平均分成五块

使用线程的理由

• 从上面我们知道了进程与线程的区别，其实这些区别也就是我们使用线程的理由。总的来说就是：进程有独立的地址空间，线程没有单独的地址空间（同一进程内的线程共享进程的地址空间）。

• 使用多线程的理由之一是和进程相比，它是一种非常"节俭"的多任务操作方式。我们知道，在Linux系统下，启动一个新的进程必须分配给它独立的地址空间，建立众多的数据表来维护它的代码段、堆栈段和数据段，这是一种"昂贵"的多任务工作方式。而运行于一个进程中的多个线程，它们彼此之间使用相同的地址空间，共享大部分数据，启动一个线程所花费的空间远远小于启动一个进程所花费的空间，而且，线程间彼此切换所需的时间也远远小于进程间切换所需要的时间。据统计，总的说来，一个进程的开销大约是一个线程开销的30倍左右，当然，在具体的系统上，这个数据可能会有较大的区别。

• 使用多线程的理由之二是线程间方便的通信机制。对不同进程来说，它们具有独立的数据空间，要进行数据的传递只能通过通信的方式进行，这种方式不仅费时，而且很不方便。线程则不然，由于同一进程下的线程之间共享数据空间，所以一个线程的数据可以直接为其它线程所用，这不仅快捷，而且方便。当然，数据的共享也带来其他一些问题，有的变量不能同时被两个线程所修改，有的子程序中声明为static的数据更有可能给多线程程序带来灾难性的打击，这些正是编写多线程程序时最需要注意的地方。

• 除了以上所说的优点外，不和进程比较，多线程程序作为一种多任务、并发的工作方式，当然有以下的优点：

  • 提高应用程序响应。这对图形界面的程序尤其有意义，当一个操作耗时很长时，整个系统都会等待这个操作，此时程序不会响应键盘、鼠标、菜单的操作，而使用多线程技术，将耗时长的操作（time consuming）置于一个新的线程，可以避免这种尴尬的情况。
  • 使多CPU系统更加有效。操作系统会保证当线程数不大于CPU数目时，不同的线程运行于不同的CPU上。
  • 改善程序结构。一个既长又复杂的进程可以考虑分为多个线程，成为几个独立或半独立的运行部分，这样的程序会利于理解和修改。

Linux上线程开发API概要

• 多线程开发在 Linux 平台上已经有成熟的 pthread 库支持【gcc编译的时候要- lpthread】。其涉及的多线程开发的最基本概念主要包含三点：线程，互斥锁，条件。其中，线程操作又分线程的创建，退出，等待 3 种。互斥锁则包括 4 种操作，分别是创建，销毁，加锁和解锁。条件操作有 5 种操作：创建，销毁，触发，广播和等待。
  
• 理解：互斥锁是为了完成同步而设计的，条件变量是为了完成通知

线程

线程的创建

//线程的创建
int pthread_create(pthread_t *restrict tidp, 
					const pthread_attr_t *restrict attr, 
					void *(*start_rtn)(void *), 
					void *restrict arg);

参数说明：

• 第一个参数是线程ID 无符号整型线程描述符，是个指针，指向一个数据类型为pthread_t的变量，用来保存新建线程的线程号
• 第二个参数是线程的属性，暂可以把它设置为NULL，以创建默认属性的线程。
• 第三个参数是线程处理函数，函数名为start_rtn的函数指针，该函数返回值是void *类型的指针（注意函数的定义）
• 第四个参数是向线程处理函数传入参数，是个指针，指向void类型（携带参数较多则选择结构体，参数少则选择一般数据类型）

返回值：

• 成功返回：0
• 错误返回：错误号（perror不能使用该函数打印错误信息）

注意：

• 当pthread_create成功返回时，由tidp指向的内存单元被设置为新创建线程的线程ID，即在子线程中使用pthread_datach()获取的tid和主线程中打印的tidp的内容时一样的
• 新创建的线程从start_rtn函数的地址开始运行，该函数只有一个无类型指针参数arg。如果需要向start_rtn函数传递的参数不止一个，那么需要把这些参数放到一个结构中，然后把这个结构的地址作为arg参数传入。
• 主线程先退出，子线程会被强制结束
• 线程直接共享全局变量

线程的退出（主动）

//线程的退出
int pthread_exit(void *rval_ptr);

参数说明：

• rval_ptr：必须指向全局，堆 ， 一般填 NULL，如果有则表示携带数据退出，带给主线程

注意：

• 在线程内调用 exit(0) 会退出整个进程，也就是其他线程也会退出
• rval_ptr是一个无类型指针，与传给启动例程的单个参数类似。进程中的其他线程可以通过调用pthread_join函数访问到这个指针。
• 线程可以被同一进程中的其他线程取消
• 线程只是从启动例程中返回，返回值是线程的退出码[即rval_ptr]。

线程的退出情况有三种：
第一种是进程结束，进程中所有的线程也会随之结束。
第二种是通过函数 pthread_exit 来主动的退出线程。
第三种被其他线程调用 pthread_cancel 来被动退出。

线程的退出（被动）

线程被动退出，其他线程使用该函数让另一个线程退出，该函数传入一个 tid 号，会强制退出该 tid 所指向的线程，若成功执行会返回 0。

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

后续会通过加锁、信号量等手段来合理的控制线程的临界资源访问与线程执行顺序控制，被动退出的方式很少使用

线程的等待（回收）（阻塞）

//线程的等待
int pthread_join(pthread_t thread, void **rval_ptr);

参数说明：

• 第一个参数是变量名（线程名），要回收的子线程的ID
• 第二个参数是无类型的二级指针，指向 pthread_exit退出函数的参数，读取线程退出的携带信息

返回值：

• 若成功返回0
• 否则返回错误编号

注意：

• 调用这个函数的线程将一直阻塞，直到指定的线程调用pthread_exit、从启动例程中返回或者被取消。
• 线程的退出和等待所携带的参数指向同一个全局变量

线程的等待（回收）（非阻塞）

#define _GNU_SOURCE
#include <pthread.h>
int pthread_tryjoin_np(pthread_t thread, void **retval);

线程的退出与回收（阻塞）实例1：

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

void *fun1(void *arg)
{
	//当变量从线程传出的时候，需要加 static 修饰，对生命周期做出延续，否则无法传出正确的变量值
	static int tmp = 0;
	//int tmp = 0;
	tmp = *(int *)arg;
	tmp+=100;
	printf("%s:Addr = %p tmp = %d\n",__FUNCTION__,&tmp,tmp);
	pthread_exit((void *)&tmp);
}


int main()
{

	pthread_t tid1;
	int a = 50;
	void *Tmp = NULL;
	int ret = pthread_create(&tid1,NULL,fun1,(void *)&a);
	if(ret != 0){
		perror("pthread_create");
		return -1;
	}
	pthread_join(tid1,&Tmp);
	printf("%s:Addr = %p Val = %d\n",__FUNCTION__,Tmp,*(int *)Tmp);
	return 0;
}

输出结果

线程的退出与回收（非阻塞）实例2：

通过阻塞方式回收线程几乎规定了线程回收的顺序，若最先回收的线程未退出，则一直会被阻塞，导致后续先退出的线程无法及时的回收。通过函数 pthread_tryjoin_np，使用非阻塞回收，线程可以根据退出先后顺序自由的进行资源的回收。

#define _GNU_SOURCE 
#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>


//多个线程可以指向同一个回调函数
void *fun(void *arg)
{
	printf("Pthread:%d Come !\n",(int )(long)arg+1);
	pthread_exit(arg);
}


int main()
{
	int ret,i,flag = 0;
	void *Tmp = NULL;
	pthread_t tid[3];
	for(i = 0;i < 3;i++){
		ret = pthread_create(&tid[i],NULL,fun,(void *)(long)i);
		if(ret != 0){
			perror("pthread_create");
			return -1;
		}
	}
	while(1){
		for(i = 0;i <3;i++){
			if(pthread_tryjoin_np(tid[i],&Tmp) == 0){
				printf("Pthread : %d exit !\n",(int )(long )Tmp+1);
				flag++;	
			}
		}
		if(flag >= 3) break;
	}
	return 0;
}

输出结果

线程的获取

//线程ID获取及比较
pthread_t pthread_self(void);

返回：调用线程的ID，pthread_t是unsigned long类型数据，用%ld打印

线程分离

int pthread_datach(pthread_t thread);

• 调用该函数之后不需要 pthread_join
• 子线程会自动回收自己的PCB

线程创建退出等待实例3：

执行流程：

• 线程创建函数执行后会执行处理函数myfunc，打印子线程的id

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
 
int num = 100;
 
// myfunc 线程
void *myfunc(void *arg)
{
	printf("child pthread id = %ld\n", pthread_self());
	for (int i = 0; i < 5; i++)
	{
		printf("child pthread i = %d\n", i);
		if (i == 2)
		{
			num = 666; // 验证不同线程可以利用全局变量通信
			// pthread_exit(NULL);  // 不携带数据的退出
			pthread_exit(&num); // 携带数据的退出
		}
	}
	return 0;
}
 
int main()
{
	int ret;
	int i = 0;
	pthread_t pthid;
	ret = pthread_create(&pthid, NULL, myfunc, NULL); // 线程创建
 
	if (ret != 0) // 创建失败判断
	{
		printf("error number is %d\n", ret);
		printf("%s\n", strerror(ret));
	}
	printf("parent pthread id = %ld\n", pthread_self());
 
	void *ptr = NULL;
	ptr = malloc(32);		   // 如果不动态申请内存会发生段错误
	void *tmp = ptr;		   // 用 tmp 指向申请的内存来操作内存，以防改变 ptr 的指向导致 free 时产生段错误
	pthread_join(pthid, &tmp); // 第二个参数是 void ** 类型的二级指针，可以用来获取 exit 参数携带的数据
	printf("num = %d\n", *(int *)tmp);
	free(ptr);	// 释放掉申请的内存
	ptr = NULL; // 指针指向 NULL 以防后续误操作
 
	while (i < 5)
	{
		i++;
		printf("parent pthread i = %d\n", i);
	}
	//因线程执行顺序随机，不加 sleep 可能导致主线程先执行，导致进程结束，无法执行到子线
	sleep(2);
 
	return 0;
}

运行结果

parent pthread id = 140648449812288
child pthread id = 140648447473344
child pthread i = 0
child pthread i = 1
child pthread i = 2
num = 666
parent pthread i = 1
parent pthread i = 2
parent pthread i = 3
parent pthread i = 4
parent pthread i = 5

互斥锁

• 类似于多进程之间通讯的信号量

• 给需要运行的线程上锁，其他线程则无法在该线程之前执行，直到锁头被解开

• 互斥量（mutex）从本质上来说是一把锁，所以也叫互斥锁，在访问共享资源前对互斥量进行加锁，在访问完成后释放互斥量上的锁。对互斥量进行加锁后，任何其他试图再次对互斥量加锁的线程将会被阻塞直到当前线程释放该互斥锁。如果释放互斥锁时有多个线程阻塞，所有在该互斥锁上的阻塞线程都会变成可运行状态，第一个变为可运行状态的线程可以对互斥量加锁，其他线程将会看到互斥锁依然被锁住，只能回去等待它重新变为可用。在这种方式下，每次只有一个线程可以向前运行。

• 在设计时需要规定所有的线程必须遵守相同的数据访问规则。只有这样，互斥机制才能正常工作。操作系统并不会做数据访问的串行化。如果允许其中的某个线程在没有得到锁的情况下也可以访问共享资源，那么即使其它的线程在使用共享资源前都获取了锁，也还是会出现数据不一致的问题。

• 互斥变量用pthread_mutex_t数据类型表示。在使用互斥变量前必须对它进行初始化，

• 使用互斥锁缺点是效率低

创建互斥锁：

在全局变量定义锁：

#include <pthread.h>
pthread_mutex_t mutex;

初始化互斥锁：

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

参数

• 第一个参数是改互斥量指针
• 第二个参数为控制互斥量的属性，一般为NULL：

返回值：

• 当函数成功后会返回 0，代表初始化互斥量成功，mutex = 1

当然初始化互斥量也可以调用宏来快速初始化，代码如下：

pthread_mutex_t mutex = PTHREAD_MUTEX_INITALIZER;

销毁互斥锁：

#include <pthread.h>
int pthread_mutex_destroy(pthread_mutex_t mutex);

返回值：

• 成功返回 0

加锁（阻塞）：

加锁，会阻塞，成功时mutex = 0

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

没有被锁上：当前线程会将这把锁锁上。被锁上了：当前线程阻塞，
锁被打开之后，线程解除阻塞。尝试加锁，失败返回，不阻塞

加锁（非阻塞）：

加锁，不会阻塞，成功时mutex = 0

int pthread_mutex_trylock(pthread_mutex_t *mutex);

没有锁上：当前线程会被这把锁加锁
如果锁上了：不会阻塞，返回
返回0：加锁 成功。没锁上：返回错误号

解锁：

int pthread_mutex_unlock(pthread_mutex_t *mutex);

解锁，成功时mutex = 1

---

shell脚本的书写

• 创建脚本文件test.sh，在脚本文件中可以写调用执行文件的语句，然后再控制面板输入：chmod +x test.sh即可将脚本转化为可执行文件，然后输入./test.sh

可以写c语言的脚本

• 创建文件，在该文件中使用循环，调用system函数，执行函数中的执行语句

• 创建的文件也可以获取用户输入的执行次数，此时需要携带参数

int main (int argc,char **argv){
    int time = atoi(argv[1]);
    for (i = 0;i <time;i++){
        system("./demo3")
    }  
}

---

死锁：

• 首先是要创建2个锁，当线程A获得一把锁的时候想要获得B获得的那一把锁时，且当线程B获得一把锁时想要获得A获得的那一把锁时，就会导致死锁

多线程与互斥锁实例

#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
 
#define MAX 10000
int number; // 全局变量默认初始化为0，共享资源
// create mutex
pthread_mutex_t mutex;
 
// 线程 A 处理函数
void *funA(void *arg)
{
	for (int i = 0; i < MAX; i++)
	{
		// Lock
		pthread_mutex_lock(&mutex);
 
		number++;
		int ret = number;
		printf("funA id = %ld, A_number = %d\n", pthread_self(), number);
 
		// Unlock
		pthread_mutex_unlock(&mutex);
		usleep(10);
	}
}
 
// 线程 B 处理函数
void *funB(void *arg)
{
	for (int i = 0; i < MAX; i++)
	{
		// Lock
		pthread_mutex_lock(&mutex);
 
		number++;
		int ret = number;
		printf("funB id = %ld, B_number = %d\n", pthread_self(), number);
 
		// Unlock
		pthread_mutex_unlock(&mutex);
		usleep(10);
	}
}
 
int main()
{
	// Init mutex
	pthread_mutex_init(&mutex, NULL); // 创建互斥锁
	pthread_t pth1, pth2;
 
	// 创建线程
	pthread_create(&pth1, NULL, funA, NULL);
	pthread_create(&pth2, NULL, funB, NULL);
 
	// 等待线程结束
	pthread_join(pth1, NULL);
	pthread_join(pth2, NULL);
 
	// 销毁互斥锁
	pthread_mutex_destroy(&mutex);
 
	return 0;
}

输出结果：

• 不能保证根据main函数创建线程的先后顺序执行，但是可以保证在同一个线程内的语句会一起执行，采用 sleep 强行延时的方法勉强可以控制执行顺序，但此方法在实际项目情况往往是不可取的，其仅仅可解决线程创建的顺序，当创建之后执行的顺序又不会受到控制，于是便引入了信号量的概念，解决线程执行顺序。

流程图

信号量

• 信号量跟互斥量不一样，互斥量用来防止多个线程同时访问某个临界资源。信号量起通知作用，线程 A 在等待某件事，线程 B 完成了这件事后就可以给线程 A 发信号
• 信号量有两种实现：传统的System V信号量和新的POSIX信号量。它们所提供的函数很容易被区分：对于所有System V信号量函数，在它们的名字里面没有下划线。例如，应该是semget()而不是sem_get()。然而，所有的的POSIX信号量函数都有一个下划线。下面列出了它们提供的所有函数清单
  

信号量数据类型：

sem_t sem;

初始化信号量

#include <semaphore.h>
sem_init(sem_t *sem,int pshared,unsigned int value);

参数：

• 第一个参数传入 sem_t 类型指针；
• 第二个参数传入 0 代表线程同步控制，否则为进程控制（1）；
• 第三个参数表示信号量的初始值，0 代表阻塞，1 代表运行

返回值：

• 若执行成功会返回 0。

销毁信号量

sem_destroy(sem_t *sem);

该函数为信号量销毁函数，执行过后可将信号量进行销毁。

申请信号量（阻塞）

#include <pthread.h>
sem_wait(sem_t *sem);

sem_wait 函数作用为检测指定信号量是否有资源可用，若无资源可用会阻塞等待，若有资源可用会自动的执行“sem-1”的操作。所谓的“sem-1”是与上述初始化函数中第三个参数值一致，成功执行会返回 0 ，如果sem值为0，线程会阻塞

申请信号量（非阻塞）

sem_trywait(sem_t *sem);

若sem == 0，此时加锁会失败，但不阻塞

执行成功返回0，执行失败返回 -1且信号量的值保持不变。

申请信号量（限时）

int sem_timedwait(sem_t *sem, const struct timespec *abs_timeout);

释放信号量

sem_post(sem_t *sem);

sem_post 函数会释放指定信号量的资源，执行“sem+1”操作

通过信号量的初始化， PV 操作，即信号量的申请与释放，完成对线程执行顺序的控制

信号量案例：

加入了信号量，使得线程的执行顺序变为可控的

在初始化信号量时，将信号量 1 填入资源，第一个线程调用 sem_wait 函数可以成功获得信号量，在执行完逻辑后使用 sem_pos 函数来释放。当执行函数 sem_wait 后，会执行 sem 自减操作，使下一次竞争被阻塞，直至通过 sem_pos 被释放

#define _GNU_SOURCE 
#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <semaphore.h>

sem_t sem1,sem2,sem3;//申请的三个信号量变量

void *fun1(void *arg)
{
	sem_wait(&sem1);//因sem1本身有资源，所以不被阻塞 获取后sem1-1 下次会会阻塞
	printf("%s:Pthread Come!\n",__FUNCTION__);
	sem_post(&sem2);// 使得sem2获取到资源
	pthread_exit(NULL);
}

void *fun2(void *arg)
{
	sem_wait(&sem2);//因sem2在初始化时无资源会被阻塞，直至14行代码执行 不被阻塞 sem2-1 下次会阻塞
	printf("%s:Pthread Come!\n",__FUNCTION__);
	sem_post(&sem3);// 使得sem3获取到资源
	pthread_exit(NULL);
}

void *fun3(void *arg)
{
	sem_wait(&sem3);//因sem3在初始化时无资源会被阻塞，直至22行代码执行 不被阻塞 sem3-1 下次会阻塞
	printf("%s:Pthread Come!\n",__FUNCTION__);
	sem_post(&sem1);// 使得sem1获取到资源
	pthread_exit(NULL);
}

int main()
{
	int ret;
	pthread_t tid1,tid2,tid3;
	ret = sem_init(&sem1,0,1);  //初始化信号量1 并且赋予其资源
	if(ret < 0){
		perror("sem_init");
		return -1;
	}
	ret = sem_init(&sem2,0,0); //初始化信号量2 让其阻塞
	if(ret < 0){
		perror("sem_init");
		return -1;
	}
	ret = sem_init(&sem3,0,0); //初始化信号3 让其阻塞
	if(ret < 0){
		perror("sem_init");
		return -1;
	}
	ret = pthread_create(&tid1,NULL,fun1,NULL);//创建线程1
	if(ret != 0){
		perror("pthread_create");
		return -1;
	}
	ret = pthread_create(&tid2,NULL,fun2,NULL);//创建线程2
	if(ret != 0){
		perror("pthread_create");
		return -1;
	}
	ret = pthread_create(&tid3,NULL,fun3,NULL);//创建线程3
	if(ret != 0){
		perror("pthread_create");
		return -1;
	}
	/*回收线程资源*/
	pthread_join(tid1,NULL);
	pthread_join(tid2,NULL);
	pthread_join(tid3,NULL);

	/*销毁信号量*/
	sem_destroy(&sem1);
	sem_destroy(&sem2);
	sem_destroy(&sem3);

	return 0;
}

运行结果

信号量流程图

读写锁

读写锁概念

• 读写锁是一把锁，而不是两把
• pthread_rwlock_t lock;

读写锁的类型

• 读锁-对内存做读操作
• 写锁-对内存做写操作

读写锁的特性

读写锁场景练习

读写锁的适用场景

主要操作函数

初始化读写锁：
    pthread_rwlock_init(pthread_rwlock_t* restrict rwlock,
    const pthread_rwlockattr_t* restrict attr );
 
销毁读写锁：
    pthread_rwlock_destroy(pthread_rwlock_t* rwlock):
 
加读锁：
    pthread_rwlock_rdlock(pthread_rwlock_t* rdlock);
阻塞：之前对这把锁加的是写锁的操作
 
尝试加读锁：
    pthread_rwlock_tryrdlock(pthread_rwlock_t* rwlock);
加锁成功：返回0
失败：返回错误号
 
加写锁：
    pthread_rwlock_wrlock(pthread_rwlock_t* rwlock);
阻塞：上一次加写锁还没解锁
阻塞：上一次加读锁还没解锁
 
尝试加写锁：
    pthread_rwlock_trywrlock(pthread_rwlock_t* rwlock);
 
解锁：
    pthread_rwlock_unlock(pthread_rwlock_t* rwlock)

实例

三个线程不定时写同一个全局变量，五个线程不定时期读同一全局资源

#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
 
int number;
// create rwlock
pthread_rwlock_t lock;
 
void *write_func(void *arg)
{
	while (number < 5000)
	{
		pthread_rwlock_wrlock(&lock); // 加写锁
		number++;
		printf("write: %ld, %d\n", pthread_self(), number);
		pthread_rwlock_unlock(&lock); // 解写锁
		usleep(500);
	}
}
 
void *read_func(void *arg)
{
	while (number < 5000)
	{
		pthread_rwlock_rdlock(&lock); // 加读锁
		printf("read: %ld, %d\n", pthread_self(), number);
		pthread_rwlock_unlock(&lock); // 解读锁
		usleep(500);
	}
}
 
int main()
{
	pthread_rwlock_init(&lock, NULL);
	pthread_t p[8];
 
	// 前三个线程是写线程
	for (int i = 0; i < 3; i++)
	{
		pthread_create(&p[i], NULL, write_func, NULL);
	}
 
	// 后五个线程是读线程
	for (int i = 3; i < 8; i++)
	{
		pthread_create(&p[i], NULL, read_func, NULL);
	}
 
	// 等待八个线程结束
	for (int i = 0; i < 8; i++)
	{
		pthread_join(p[i], NULL);
	}
 
	// 销毁读写锁
	pthread_rwlock_destroy(&lock);
	return 0;
}

结果：

条件变量

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

创建条件变量

#include <pthread.h>
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;;//全局定义条件变量
int pthread_cond_init(pthread_cond_t *restrict cond, 
						const pthread_condattr_t *restrict attr);

• 除非需要创建一个非默认属性的条件变量，否则 pthread_cont_init 函数的 attr 参数可以设置为NULL。

• 成功时都返回

• 使用宏可以完成静态初始化，互斥量也可以静态初始化

全局定义条件变量：pthread_cond_t cond;
动态初始化：pthread_cond_init(&cond,NULL);
静态初始化：pthread_cond_t(PTHREAD_COND_INITIALIZER);

互斥锁也可以静态初始化
全局定义互斥变量：pthread_mutex_t;
动态初始化：pthread_mutex_init(&mutex,NULL);
静态初始化：pthread_mutex_t(PTHREAD_MUTEX_INITIALIZER);

销毁条件变量

int pthread_cond_destroy(pthread_cond_t *restrict cond);
// 返回：若成功返回0，否则返回错误编号

• 成功时都返回

等待条件变量

#include <pthread.h>
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, 
							 cond struct timespec *restrict timeout);
// 返回：若成功返回0，否则返回错误编号

• 阻塞等待一个条件变量，将已经上锁的mutex解锁，该函数解除阻塞，对互斥锁加锁

• pthread_cond_wait等待条件变为真。如果在给定的时间内条件不能满足，那么会生成一个代表一个出错码的返回变量。传递给pthread_cond_wait的互斥量对条件进行保护，调用者把锁住的互斥量传给函数。函数把调用线程放到等待条件的线程列表上，然后对互斥量解锁，这两个操作都是原子操作。这样就关闭了条件检查和线程进入休眠状态等待条件改变这两个操作之间的时间通道，这样线程就不会错过条件的任何变化。pthread_cond_wait返回时，互斥量再次被锁住。

• pthread_cond_timedwait函数的工作方式与pthread_cond_wait函数类似，只是多了一个timeout。timeout指定了等待的时间，它是通过timespec结构指定。

这需要结合互斥量一起使用

pthread_mutex_lock(&g_tMutex);
// 如果条件不满足则，会 unlock g_tMutex
// 条件满足后被唤醒，会 lock g_tMutex
pthread_cond_wait(&g_tConVar, &g_tMutex);
/* 操作临界资源 */
pthread_mutex_unlock(&g_tMutex);

通知条件变量

#include <pthread.h>
int pthread_cond_signal(pthread_cond_t *restrict cond);
int pthread_cond_broadcast(pthread_cond_t *restrict cond);
// 返回：若成功返回0，否则返回错误编号

• 【起通知的效果，类似于进程间的通信中的信号】，这两个函数可以用于通知线程条件已经满足。pthread_cond_signal函数将唤醒等待该条件的某个（单个）线程，而pthread_cond_broadcast函数将唤醒等待该条件的所有进程。

• 注意一定要在改变条件状态以后再给线程发信号。

使用线程完成生产者消费者模型

Linux-生产者消费者模型

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
 
typedef struct node
{
	int data;
	struct node *next;
} Node;
 
Node *head = NULL;	   // create head node
pthread_mutex_t mutex; // create mutex
pthread_cond_t cond;   // create cond
 
// 生产者
void *producer(void *arg)
{
	while (1)
	{
		Node *pnew = (Node *)malloc(sizeof(Node)); // create node
		pnew->data = rand() % 500;				   // 给 data 赋值 500 内的随机数
 
		pthread_mutex_lock(&mutex); // lock
 		// 对共享资源的操作
		// 头插法插入链表
		pnew->next = head;
		head = pnew;
		printf("produce: %ld, %d\n", pthread_self(), pnew->data);
 
		pthread_mutex_unlock(&mutex); // unlock
		pthread_cond_signal(&cond);	  // 通知消费者消费
		sleep(rand() % 3);
		free(pnew); // 释放内存
	}
	return 0;
}
 
// 消费者
void *customer(void *arg)
{
	while (1)
	{
		Node *pdel = (Node *)malloc(sizeof(Node));
		pthread_mutex_lock(&mutex); // lock
		// 在互斥锁里面对共享资源进行操作
 		// 因为利用头插法，判断头结点是否为空指针，若为空指针，则阻塞等待信号
		if (head == NULL)
		{
			pthread_cond_wait(&cond, &mutex); // 阻塞等待生产者的信号
		}
 		// 若头结点不为空指针，则在删除头结点前获取头结点数据
 		// 此时 生产者生产一个节点，消费者就删除一个
		// delete head node
		pdel = head;
		head = head->next;
		printf("customer: %ld, %d\n", pthread_self(), pdel->data);
		free(pdel); // 释放内存
 
		pthread_mutex_unlock(&mutex); // unlock
	}
	return 0;
}
 
int main()
{
	// 创建线程
	pthread_t p1, p2;
	pthread_create(&p1, NULL, producer, NULL);
	pthread_create(&p2, NULL, customer, NULL);
 
	// 初始化互斥锁和条件变量
	pthread_mutex_init(&mutex, NULL);
	pthread_cond_init(&cond, NULL);
 
	// 等待线程结束
	pthread_join(p1, NULL);
	pthread_join(p2, NULL);
 
	// 销毁线程的互斥锁和条件变量
	pthread_mutex_destroy(&mutex);
	pthread_cond_destroy(&cond);
	return 0;
}