一、线程互斥方式。 --- 互斥锁 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; }
