互斥量(互斥锁)

一、互斥量mutex

Linux提供一把互斥锁mutex(也称之为互斥量)
每个线程在对资源操作前都尝试先加锁，成功加锁才能操作，操作结束后解锁。
资源还是共享的，线程间也还是竞争的，但通过锁将资源的访问变为互斥操作，而后与时间有关的错误也不会在产生了。

如图所示：

但是应该注意：同一个时刻，只能有一个线程持有该锁。

当A线程对某个全局变量加锁访问，B在访问前尝试加锁，拿不到锁，B阻塞。C线程不去加锁，而直接访问该全局变量，依然能够访问，但会出现数据混乱。

所以，互斥锁实质上是是操作系统提供的一把“建议锁”(又称“协同所”)，建议程序中有多线程访问共享资源的时候使用该机制，但是，并没有强制限定。

二、主要应用函数

分析：

pthread_mutex_t 类型，其本质是一个结构体，为简化理解，应用时可忽略其实现细节，简单当成整数看待。
pthread_mutex_t mutex：变量mutex只有两种取值0、1；

1. 函数原型：

功能：初始化一个互斥锁(互斥量)； $\rightarrow$ 初值可看做1

#include<pthread.h>
pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);                                                返回值：若成功，返回0，否则，返回错误编号

参数1：传出参数，调用时应传&mutex

restrict关键字：只用于限制指针，告诉编译器，所有修改该指针指向内存中内容的操作，只能通过本指针完成。不能通过除本指针以外的其他变量或指针修改。

参数2：互斥属性。是一个传入参数，通常传NULL，选用默认属性(线程间共享).

静态初始化：如果互斥锁mutex是静态分配的(定义在全局，或加了static关键字修饰），可以直接使用宏进行初始化。pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
动态初始化：局部变量应采用动态初始化。pthread_mutex_init(&mutex, NULL);

2. 函数原型：

功能：销毁一个互斥锁

#include<pthread.h>
pthread_mutex_destroy(pthread_mutex_t *mutex); 返回值：若成功，返回0，否则，返回错误编号

3. 函数原型：

功能：加锁。可理解为将mutex--（或-1）

#include<pthread.h>
pthread_mutex_lock(pthread_mutex_t *mutex);返回值：若成功，返回0，否则，返回错误编号

分析：

没有被上锁，当前线程会将这把锁锁上
被锁上了：当前线程阻塞，锁被打开之后，线程解除阻塞。

4. 函数原型：

功能：解锁。可理解为将mtex++（或+1）

#include<pthread.h>
pthread_mutex_unlock(pthread_mutex_t *mutex);返回值：若成功，返回0，否则，返回错误编号

注意：

同时将阻塞在该锁上的所有线程全部唤醒

5. 函数原型：

功能：尝试加锁, 失败返回, 不阻塞

#include<pthread.h>
pthread_mutex_trylock(pthread_mutex_t *mutex);返回值：若成功，返回0，否则，返回错误编号

分析：

没有锁上：当前线程会给这把锁加锁
如果锁上了：不会阻塞，返回

三、程序清单(一）

1. 测试代码：

#include <stdio.h>
#include <string.h>
#include <pthread.h>
#include <stdlib.h>
#include <unistd.h>void *tfn(void *arg)
{srand(time(NULL));while(1) {printf("hello ");sleep(rand() % 3); //模拟长时间操作共享资源，导致cpu易主，产生与时间有关的错误printf("word\n");sleep(rand() % 3);}return NULL;
}int main()
{pthread_t tid;srand(time(NULL));pthread_create(&tid, NULL, tfn, NULL);while(1) {printf("HELLO ");sleep(rand() % 3);printf("WORLD\n");sleep(rand() % 3);}return 0;
}

运行结果：

2. 测试代码：

#include<pthread.h>
#include<stdlib.h>
#include<unistd.h>pthread_mutex_t mutex;void *tfn(void *arg)
{srand(time(NULL));while(1) {pthread_mutex_lock(&mutex);printf("hello ");sleep(rand() % 3);  //模拟长时间共享资源，导致cpu易主。产生于时间有关的错误 printf("word\n");pthread_mutex_unlock(&mutex);sleep(rand() % 3);}return NULL;
}int main()
{pthread_t tid;srand(time(NULL));pthread_mutex_init(&mutex, NULL);pthread_create(&tid, NULL, tfn, NULL);  //mutex == 1while(1) {pthread_mutex_lock(&mutex);printf("HELLO ");sleep(rand() % 3);printf("WORLD\n");pthread_mutex_unlock(&mutex);sleep(rand() % 3);}pthread_mutex_destroy(&mutex);return 0;
}

输出结果：

3. 测试代码：

#include<pthread.h>
#include<stdlib.h>
#include<unistd.h>pthread_mutex_t mutex;void *tfn(void *arg)
{srand(time(NULL));while(1) {pthread_mutex_lock(&mutex);printf("hello ");sleep(rand() % 3);  //模拟长时间共享资源，导致cpu易 主。产生于时间有关的错误 printf("word\n");sleep(rand() % 3);pthread_mutex_unlock(&mutex);}return NULL;
}int main()
{pthread_t tid;srand(time(NULL));pthread_mutex_init(&mutex, NULL);pthread_create(&tid, NULL, tfn, NULL);  //mutex == 1while(1) {pthread_mutex_lock(&mutex);printf("HELLO ");sleep(rand() % 3);printf("WORLD\n");       sleep(rand() % 3);pthread_mutex_unlock(&mutex);}pthread_mutex_destroy(&mutex);return 0;
}

输出结果：