互斥量(互斥锁)

一、互斥量mutex

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

如图所示：

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

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

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

 

二、主要应用函数

分析：

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

1. 函数原型：

功能：初始化一个互斥锁(互斥量)； 初值可看做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 == 1
    while(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 == 1
    while(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;
}

输出结果：

四、程序清单(二）

四、加锁与解锁

lock与unlock：

• lock尝试加锁，如果加锁不成功，线程阻塞，阻塞到持有该互斥量的其他线程解锁为止。
• unlock主动解锁，同时将阻塞到该锁上所有线程全部唤醒，至于哪个线程先被唤醒取决于优先级，调度。默认：先阻塞、先唤醒。

例如：T1 T2 T3 T4 使用一把mutex锁，T1加锁成功，其他线程均阻塞，直至T1解锁，T1解锁后，T2 T3 T4均被唤醒，并自动再次尝试加锁。

可假想mutex锁init成功初值为1。lock功能是将mutex--。unlock将mutex++。

 

lock与trylock：

• lock加锁失败会阻塞，等待锁释放。
• trylock加锁失败直接返回错误号（如EBUSY），不阻塞。

 

注意：在访问共享资源前加锁，访问结束后立即解锁。锁的“粒度”越小越好。