互斥锁，读写锁

柔光的暖阳◎ 2022-12-12 15:05 477阅读 0赞

一、线程互斥方式。 --- 互斥锁  
1、什么是互斥锁？特点怎么样？  
互斥锁是专门用于处理线程之间互斥的一种方式，它有两种：上锁状态/解锁状态。  
如果互斥锁处于上锁状态，那么再上锁就会阻塞，直到这把锁解开之后，才能上锁。  
如果互斥锁处于解锁状态，那么再解锁依然可以的，不会阻塞。

2、 互斥锁函数接口？  
1）定义互斥锁变量 -> 数据类型： pthread\_mutex\_t  
pthread\_mutex\_t m;

2）初始化互斥锁。 -> pthread\_mutex\_init() -> man 3 pthread\_mutex\_init  
动态初始化：  
头文件：  
\#include <pthread.h>

原型：  
int pthread\_mutex\_init(pthread\_mutex\_t \*mutex, const pthread\_mutexattr\_t \*mutexattr);

参数：  
mutex：互斥锁变量的地址。  
mutexattr：普通属性，填NULL。

返回值：  
成功：0  
失败：非0

静态初始化：  
pthread\_mutex\_t m = PTHREAD\_MUTEX\_INITIALIZER;  
只要把该宏定义赋值给互斥锁变量，就等价于初始化了这把互斥锁。

========================  
也就是说：  
pthread\_mutex\_t m = PTHREAD\_MUTEX\_INITIALIZER;

等价于  
pthread\_mutex\_t m;  
pthread\_mutex\_init(&m,NULL);

3）上锁。 -> pthread\_mutex\_lock() -> man 3 pthread\_mutex\_lock  
头文件：  
\#include <pthread.h>

原型：  
int pthread\_mutex\_lock(pthread\_mutex\_t \*mutex);

参数：  
mutex：互斥锁变量的地址。

返回值：  
成功：0  
失败：非0

4）解锁。 -> pthread\_mutex\_unlock() -> man 3 pthread\_mutex\_unlock  
头文件：  
\#include <pthread.h>

原型：  
int pthread\_mutex\_unlock(pthread\_mutex\_t \*mutex);

参数：  
mutex：互斥锁变量的地址。

返回值：  
成功：0  
失败：非0

5）销毁互斥锁。 -> pthread\_mutex\_destroy() -> man 3 pthread\_mutex\_destroy  
头文件：  
\#include <pthread.h>

原型：  
int pthread\_mutex\_destroy(pthread\_mutex\_t \*mutex);

参数：  
mutex：互斥锁变量的地址。

返回值：  
成功：0  
失败：非0

一般地：  
多个线程任务都一样的 -> 互斥锁  
多个线程任务不一样的 -> 无名信号量

练习1： 使用互斥锁完成5个线程打印helloworld。 -> 多个线程任务都一样的  
练习2： 使用互斥锁完成<练习.docx> -> 多个线程任务不一样的

二、线程互斥方式。 -- 读写锁  
1、互斥锁有什么缺陷？  
互斥锁无论是读取共享资源，还是修改共享资源，都要上锁，而且在上锁期间，不能被别的线程上锁。

访问资源（一起读一本书） -> 同时上读锁 -> 读锁就是一把共享锁。  
修改资源（一起做一份试卷） -> 不能同时上写锁 -> 写锁就是一把互斥锁。

这把既有读锁，又有写锁的锁，就称之为读写锁。

2、读写锁函数接口？  
1）定义一个读写锁变量。 数据类型： pthread\_rwlock\_t  
pthread\_rwlock\_t rwlock;

2）初始化读写锁？ -> pthread\_rwlock\_init() -> man 3 pthread\_rwlock\_init  
动态初始化：  
头文件：  
\#include <pthread.h>

原型：  
int pthread\_rwlock\_init(pthread\_rwlock\_t \*restrict rwlock,  
const pthread\_rwlockattr\_t \*restrict attr);

参数：  
rwlock： 读写锁的地址。  
attr： 普通属性，填NULL。

返回值：  
成功：0  
失败：非0

静态初始化：  
pthread\_rwlock\_t rwlock = PTHREAD\_RWLOCK\_INITIALIZER;

3）读锁上锁。 -> pthread\_rwlock\_rdlock() -> man 3 pthread\_rwlock\_rdlock  
头文件：  
\#include <pthread.h>

原型：  
int pthread\_rwlock\_rdlock(pthread\_rwlock\_t \*rwlock);

参数：  
rwlock： 读写锁的地址。

返回值：  
成功：0  
失败：非0

4）写锁上锁。 -> pthread\_rwlock\_wrlock() -> man 3 pthread\_rwlock\_wrlock  
头文件：  
\#include <pthread.h>  
原型：  
int pthread\_rwlock\_wrlock(pthread\_rwlock\_t \*rwlock);

参数：  
rwlock： 读写锁的地址。

返回值：  
成功：0  
失败：非0

5）解锁。 -> pthread\_rwlock\_unlock() -> man 3 pthread\_rwlock\_unlock  
头文件：  
\#include <pthread.h>

原型：  
int pthread\_rwlock\_unlock(pthread\_rwlock\_t \*rwlock);

参数：  
rwlock： 读写锁的地址。

返回值：  
成功：0  
失败：非0

6）销毁读写锁。 -> pthread\_rwlock\_destroy() -> man 3 pthread\_rwlock\_destroy  
头文件：  
\#include <pthread.h>  
原型：  
int pthread\_rwlock\_destroy(pthread\_rwlock\_t \*rwlock);

参数：  
rwlock： 读写锁的地址。

返回值：  
成功：0  
失败：非0

练习3： 现有一个临界资源： "int a" -> 全局变量  
现在有4个线程，有两个线程想打印a的值 -> 读  
thread1: 3S thread2:5S -> 看时间 -> 如果读完需要8S，则读锁不能同时上

有两个线程想修改a的值，一个想改成30，一个想改成50 -> 写  
thread3: 4S thread4: 6S  
再开一条线程，用于倒数时间就行。

验证：1）读锁可以同时上，写锁不可以同时上。  
2）读锁与写锁能不能同时上？ -> 不可以，读锁要等到写锁解开了之后才能上锁。  
  
\#include "head.h"

int a = 100; //临界资源  
pthread\_rwlock\_t rwlock = PTHREAD\_RWLOCK\_INITIALIZER;

void \*func\_time(void \*arg)  
\{  
int i;  
for(i=0;i<1000;i++)  
\{  
printf("i = %d\\n",i);  
sleep(1);  
\}  
\}

//线程1： 打印a的值。 -> 3S (读操作)  
void \*func1(void \*arg)  
\{  
//1. 访问资源前，先上读锁。  
pthread\_rwlock\_rdlock(&rwlock);  
printf("thread 1 rdlock lock!\\n");  
  
//2. 打印a的值。  
printf("a = %d\\n",a);  
  
//3. 持续3S  
sleep(3);  
  
//4. 访问完资源了，需要解锁。  
pthread\_rwlock\_unlock(&rwlock);  
printf("thread 1 rdlock unlock!\\n");  
  
//5. 线程退出  
pthread\_exit(NULL);  
\}

//线程2： 打印a的值。 -> 5S (读操作)  
void \*func2(void \*arg)  
\{  
//1. 访问资源前，先上读锁。  
pthread\_rwlock\_rdlock(&rwlock);  
printf("thread 2 rdlock lock!\\n");  
  
//2. 打印a的值。  
printf("a = %d\\n",a);  
  
//3. 持续5S  
sleep(5);  
  
//4. 访问完资源了，需要解锁。  
pthread\_rwlock\_unlock(&rwlock);  
printf("thread 2 rdlock unlock!\\n");  
  
pthread\_exit(NULL);  
\}

//线程3：修改a的值为50。 -> 4S  
void \*func3(void \*arg)  
\{  
//1. 修改资源之前，需要上写锁。  
pthread\_rwlock\_wrlock(&rwlock);  
printf("thread 3 wrlock lock!\\n");  
  
//2. 修改临界资源。  
a = 50;  
  
//3. 持续一段时间。  
sleep(4);  
  
//4. 修改资源后，需要解锁。  
pthread\_rwlock\_unlock(&rwlock);  
printf("thread 3 wrlock unlock!\\n");  
  
pthread\_exit(NULL);  
  
\}

//线程4：修改a的值为30。 -> 6S  
void \*func4(void \*arg)  
\{  
//1. 修改资源之前，需要上写锁。  
pthread\_rwlock\_wrlock(&rwlock);  
printf("thread 4 wrlock lock!\\n");  
  
//2. 修改临界资源。  
a = 100;  
  
//3. 持续一段时间。  
sleep(6);  
  
//4. 修改资源后，需要解锁。  
pthread\_rwlock\_unlock(&rwlock);  
printf("thread 4 wrlock unlock!\\n");  
  
pthread\_exit(NULL);  
\}

int main(int argc,char \*argv\[\])  
\{  
//0. 创建一个用于倒数时间线程  
pthread\_t tid\_time;  
pthread\_create(&tid\_time,NULL,func\_time,NULL);  
  
//1、 创建2个子线程，用于打印临界资源的值。  
pthread\_t tid1,tid2,tid3,tid4;  
pthread\_create(&tid1,NULL,func1,NULL);  
pthread\_create(&tid2,NULL,func2,NULL);  
pthread\_create(&tid3,NULL,func3,NULL);  
pthread\_create(&tid4,NULL,func4,NULL);  
  
//2. 接合线程  
pthread\_join(tid1,NULL);  
pthread\_join(tid2,NULL);  
pthread\_join(tid3,NULL);  
pthread\_join(tid4,NULL);  
  
//3. 销毁读写锁  
pthread\_rwlock\_destroy(&rwlock);  
  
return 0;  
\}