Linux线程同步之互斥量加锁解锁

前言

1. 线程通信 只需要操作 共享的进程数据段 即可，虽然很容易，但也有其弊端，正因为并发的线程访问了相同的资源，所以造成了数据的不确定性。因此，线程的通信需要结合一些同步互斥机制一起使用

2. 假如没有一些同步互斥机制，一个线程在读一个全局变量时，刚好另外一个线程在写这个全局变量，就容易造成数据的混乱

1. 什么是互斥锁

1. 互斥锁是用以保护对共享资源的操作，即保护线程对共享资源的操作代码可以完整执行，而不会在访问的中途被其他线程介入对共享资源访问。
2 .互斥量也称为互斥锁，对共享资源进行锁定，保证同一时刻只能有一个线程去操作。

• 注意: 互斥锁是多个线程一起去抢，抢到锁的线程先执行，没有抢到锁的线程需要等待，等互斥锁使用完释放后，其它等待的线程再去抢这个锁。

2、互斥锁的使用

1. 使用之前需要先初始化一个互斥锁
2 .如果线程加锁成功，则可以访问共享资源，期间不会被打断，在访问结束之后解锁
3. 线程在进行上锁时，其锁资源被其他线程持有，那么该线程则会执行阻塞等待，等待锁资源被解除之后，才可以进行加锁
4. 互斥锁并不能保证线程的执行先后，但却可以保证对共享资源操作的完整性

3、什么是共享资源

通常把对共享资源操作的代码段，称之为临界区，其共享资源也可以称为 临界资源 。于是这种机制—— 互斥锁的工作原理就是对临界区进行加锁 ，保证处于临界区的线程不被其他线程打断，确保其临界区运行完整。

4、与互斥锁相关的API

（1）创建互斥锁

pthread_mutex_t mutex;    //此创建的互斥锁为全局变量

（2）pthread_mutex_init()____初始化互斥锁

#include <pthread.h>
int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);
 
pthread_mutex_t *restrict mutex：           锁的地址
const pthread_mutexattr_t *restrict attr：  锁的属性，默认写NULL
 
// 返回：若成功返回0，否则返回错误编号

（3）pthread_mutex_destroy()___销毁互斥锁

#include <pthread.h>
int pthread_mutex_destroy(pthread_mutex_t *mutex);
 
pthread_mutex_t *mutex:      锁的地址，是一个指针
 
// 返回：若成功返回0，否则返回错误编号

（4）pthread_mutex_lock()___加锁

#include <pthread.h>
int pthread_mutex_lock(pthread_mutex_t *mutex);
 
pthread_mutex_t *mutex:      锁的地址，是一个指针
// 返回：若成功返回0，否则返回错误编号

（5）pthread_mutex_unlock()___解锁

#include <pthread.h>
int pthread_mutex_unlock(pthread_mutex_t *mutex);
 
pthread_mutex_t *mutex：     锁的地址，是一个指针
// 返回：若成功返回0，否则返回错误编号

• 举例：如何创建一个互斥锁代码实现：

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

int g_data = 0;
pthread_mutex_t mutex;                  //创建一个互斥锁
 
void *func1(void *arg){
    int i;
    pthread_mutex_lock(&mutex);         //加锁
    for(i=0;i<5;i++){
 
        printf("t1:%ld thread is create\n",(unsigned long)pthread_self());
        printf("t1:param is %d\n",*((int *)arg));
        sleep(1);
    }
    pthread_mutex_unlock(&mutex);       //解锁
}
 
void *func2(void *arg){
 
        pthread_mutex_lock(&mutex);    //加锁
 
        printf("t2:%ld thread is create\n",(unsigned long)pthread_self());
        printf("t2:param is %d\n",*((int *)arg));
 
    pthread_mutex_unlock(&mutex);      //解锁   
}
 
int main(){
    
    int ret;
    int param = 100;
    
    pthread_t t1;
    pthread_t t2;
    pthread_mutex_init(&mutex,NULL);    //初始化互斥锁
 
    ret = pthread_create(&t1,NULL,func1,(void *)&param);
    if(ret == 0){
        printf("main:pthread_create success\n");
    }
 
    ret = pthread_create(&t2,NULL,func2,(void *)&param);
        if(ret == 0){
                printf("main:pthread_create success\n");
        }
 
    printf("mian:%ld\n",(unsigned long)pthread_self());
    pthread_join(t1,NULL);
    pthread_join(t2,NULL);
 
    pthread_mutex_destroy(&mutex);     //销毁互斥锁
    return 0;
}

执行结果：

• 举例：互斥锁限制共享资源的访问：

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

int g_data = 0;
pthread_mutex_t mutex;
void *func1(void *arg){
    
    printf("t1:%ld thread is create\n",(unsigned long)pthread_self());
    printf("t1:param is %d\n",*((int *)arg));
    pthread_mutex_lock(&mutex);
 
    while(1){
        printf("t1:%d\n",g_data++);
        sleep(1);
        if(g_data == 3){            
            pthread_mutex_unlock(&mutex);
            printf("t1 quit =============================\n");
            exit(0);
        }
    }    
}
 
void *func2(void *arg){
 
        
        printf("t2:%ld thread is create\n",(unsigned long)pthread_self());
        printf("t2:param is %d\n",*((int *)arg));
    while(1){
                printf("t2:%d\n",g_data);
        pthread_mutex_lock(&mutex);
        g_data++;
        pthread_mutex_unlock(&mutex);
                sleep(1);
        }      
}
 
int main(){
    
    int ret;
    int param = 100;
    pthread_t t1;
    pthread_t t2;
    pthread_mutex_init(&mutex,NULL);
    
 
    ret = pthread_create(&t1,NULL,func1,(void *)&param);
    if(ret == 0){
        printf("main:pthread_create success\n");
    }
 
    ret = pthread_create(&t2,NULL,func2,(void *)&param);
        if(ret == 0){
                printf("main:pthread_create success\n");
        }
 
    printf("mian:%ld\n",(unsigned long)pthread_self());
    while(1){
 
                printf("main:%d\n",g_data);
                sleep(1);
        }
 
    pthread_join(t1,NULL);
    pthread_join(t2,NULL);
 
    pthread_mutex_destroy(&mutex);
    return 0;
 
}

执行结果：

5什么情况会造成死锁

• 死锁定义

1. 首先要有两把锁A和B，当线程1先获得A锁后，想要再去获得B锁，这时线程2手里已经获得B锁后，想要再去获得A锁，这样线程1和线程2都想要拿到对方手里的那把锁，而且谁也不让着谁，谁都不肯去解锁。

2 .死锁是指在一组进程中的各个进程均占有不会释放的资源，但因互相申请被其他进程所站用不会释放的资源而处于的一种 永久等待状态
3 . 多个线程对多个互斥锁交叉使用，每一个线程都试图对其他线程所持有的互斥锁进行加锁。

• 死锁的四个必要条件

互斥： 一个资源每次只能被一个执行流使用
请求与保持： 一个执行流申请对方资源但对方不给资源
不剥夺 ：一个执行流已获得的资源，在末使用完之前，不能强行剥夺
循环等待： 若干执行流之间形成一种头尾相接的循环等待资源的关系

• 避免死锁

破坏死锁的四个必要条件
加锁顺序一致
避免锁未释放的场景
资源一次性分配

• 银行家算法

当线程向系统申请资源时，系统必须判断如果分配了资源，会不会导致资源不安全的状态；会，就不分配；否则就分配

死锁代码示例：

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

int g_data = 0;
pthread_mutex_t mutex;
pthread_mutex_t mutex2;
 
 
void *func1(void *arg){
    int i;
    pthread_mutex_lock(&mutex);
    sleep(1);
    pthread_mutex_lock(&mutex2);
    for(i=0;i<5;i++){
 
        printf("t1:%ld thread is create\n",(unsigned long)pthread_self());
        printf("t1:param is %d\n",*((int *)arg));
        sleep(1);
    }
    pthread_mutex_unlock(&mutex);
}
 
void *func2(void *arg){
 
    pthread_mutex_lock(&mutex2);
    sleep(1);
    pthread_mutex_lock(&mutex);
 
        printf("t2:%ld thread is create\n",(unsigned long)pthread_self());
        printf("t2:param is %d\n",*((int *)arg));
 
    pthread_mutex_unlock(&mutex);       
}
 
int main(){
    
    int ret;
    int param = 100;
    
    pthread_t t1;
    pthread_t t2;
    pthread_mutex_init(&mutex,NULL);
    pthread_mutex_init(&mutex2,NULL);
 
    ret = pthread_create(&t1,NULL,func1,(void *)&param);
    if(ret == 0){
        printf("main:pthread_create success\n");
    }
 
    ret = pthread_create(&t2,NULL,func2,(void *)&param);
        if(ret == 0){
                printf("main:pthread_create success\n");
        }
 
    printf("mian:%ld\n",(unsigned long)pthread_self());
    pthread_join(t1,NULL);
    pthread_join(t2,NULL);
 
    pthread_mutex_destroy(&mutex);
    pthread_mutex_destroy(&mutex2);
    return 0;
}

执行结果：