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;
}

执行结果:

  • 0
    点赞
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值