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

最新推荐文章于 2023-07-21 17:15:31 发布
最新推荐文章于 2023-07-21 17:15:31 发布
阅读量394 收藏 2
点赞数
文章标签： c语言 linux unix Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_69211839/article/details/129291088
版权

前言

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

执行结果：

int data
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Linux 锁、条件变量、信号量
qq_40944811的博客
03-21 196
锁、条件变量、信号量
Linux线程的加锁
CHJBL的博客
07-13 464
抢票，加锁解锁，锁的原理，可重入与线程安全
线程同步之互斥量（互斥锁）
StudyWinter的博客
06-23 624
所谓同步， 即同时起步，协调一致。不同的对象， 对“同步” 的理解方式略有不同。 如，设备同步，是指在两个设备之间规定一个共同的时间参考； 数据库同步， 是指让两个或多个数据库内容保持一致，或者按需要部分保持一致； 文件同步， 是指让两个或多个文件夹里的文件保持一致等等。而编程中、 通信中所说的同步与生活中大家印象中的同步概念略有差异。“同” 字应是指协同、协助、互相配合。主旨在协同步调，按预定的先后次序运行。同步即协同步调，按预定的先后次序运行。线程同步，指一个线程发出某一功能调用时，在没有得到结果之前，
解决多线程使用全局变量时需要不断加锁和解锁的问题
思我所
06-03 4726
在多线程编程中，如果多个线程都需要对同一个全局变量进行赋值或者读取操作，那么在每次赋值或读取时，为了确保线程安全，都必须要进行加锁和解锁的操作，这样会在编程时带来很多麻烦。特别是线程多、全局变量多的时候，需要不断地加锁和解锁。 传统的全局变量使用方法如下： global_variables.h: // 1.无人机 extern Drone g_drone; extern std::mutex drone_mutex; // 2.无人车 extern Vehicle g_vehicle; extern st
Pthread线程同步总结——APUE学习笔记
Programmerist的专栏
06-29 171
扩展一下，如果本来不止AB两个线程在阻塞，而是多个线程在阻塞，那么因为使用if，所有的线程可能都被唤醒，接着不管条件x是否满足，全都往下执行，则发生了“惊群效应”。首次判断时x==1，此时进入if块内，执行wait函数，当前线程阻塞。以上，不管是为了防止虚假唤醒或是惊群效应，本质都是由于线程被唤醒是一回事、条件满足是另一回事，被唤醒不代表条件一定被满足，因此唤醒后需要再检查一遍条件，只有使用while才能在循环中再判断一次，而if不能，所以pthread_cond_wait函数常与while搭配使用。
Linux系统编程之线程同步
05-08
Linux中提供一把互斥锁mutex（也称之为互斥量）。 每个线程在对资源操作前都尝试先加锁，成功加锁才能操作，操作结束解锁。 资源还是共享的，线程间也还是竞争的， 但通过“锁”就将资源的访问变成互斥操作...
Linux多线程同步方法
08-13
在Linux系统中，常用的多线程同步方法有两种：互斥量和信号量。 1. 互斥量（Mutex） 互斥量是一种锁机制，它可以保护共享资源，确保同一时间只有一个线程访问数据。互斥量可以通过pthread的互斥接口来实现。例如，...
Linux线程管理必备:解析互斥量与条件变量的详解
09-05
互斥量的操作包括加锁和解锁。加锁通过`pthread_mutex_lock`函数实现，如果互斥量已被锁定，调用线程会被阻塞，直到锁被释放。`pthread_mutex_trylock`函数是非阻塞版本，如果互斥量已被锁定，它会立即返回EBUSY，而...
多线程编程之：Linux线程编程
08-02
POSIX 中提供了两种线程同步机制，分别为互斥锁和信号量。这两个同步机制可以互相通过调用对方来实现，但互斥锁更适合用于同时可用的资源是惟一的情况；信号量更适合用于同时可用的资源为多个的情况。 互斥锁是一个...
Linux多线程的互斥与同步控制及实践.pdf
09-07
一个经典的多线程同步问题就是生产者-消费者问题。在这个问题中，生产者线程负责生成产品放入缓冲区，而消费者线程负责从缓冲区取出并消费产品。为了确保生产者不会在缓冲区满时添加产品，消费者不会在缓冲区为空时...
glibc nptl库pthread_mutex_lock和pthread_mutex_unlock浅析
a7980718的专栏
03-16 5588
一、futex简介 futex全称是fast user-space locking，也就是快速用户空间锁,在linux下使用C语言写多线程程序时，在需要线程同步的地方会经常使用pthread_mutex_lock()函数对临界区进行加锁，如果加锁失败线程就会挂起，这就是互斥锁。但是pthread_mutex_lock并不是立即进行系统调用，而是首先在用户态进行CAS操作，判断其它线程是...
keepAliveTime为0以及队列太小导致ThreadPoolExecutor不断创建新线程
thewindkee的博客
08-12 3193
产生原因 群友问题： 使用ThreadPoolExecutor实现固定大小的线程池，但是程序跑一段时间后，就会重新创建新的线程，求问有人遇到过这个问题吗？ 询问工作队列，最大线程数，超时时间参数值设置 猜测 怀疑 keepAliveTime为0，导致runWorker期间，getTask不等待。 线程池 new ThreadPoolExecutor(corePoolSize, max...
pthread_mutex 互斥锁
最新发布
tianyexing2008的博客
07-21 1336
互斥锁相信大家都知道其作用了，就是用来排他性的访问共享资源，那也就是说哪个线程抢到了锁那这个线程就可以独占这个共享资源，其他线程只能排队等待了。那互斥锁的用法其实也不复杂，在需要独占访问的资源地方加锁即可。
通俗介绍Linux条件变量和锁
不断debug，优化中……
04-09 588
不管是面试还是工作，在做linux应用时，是经常遇到的。结合例子简单介绍锁和条件变量。
c++ 全局对象 多线程共用_Linux下,多线程程序中对全局变量应当如何操作?
weixin_42318912的博客
01-17 421
问题描述有一个初始值为n的全局变量作为计数器,然后用n个线程,每个线程将计数器减1,将这个计数器减少到0;在n比较大的时候, 得不到正确结果.使用了pthread线程和std::thread,尝试了用pthread_mutex, std::mutex, 以及__atomic_sub_fetch进行加锁或者原子减,都得不到正确结果当n为10的时候,可以得到正确结果.当n为100的时候,得不到正确结果...
全局变量加锁问题：
weixin_45895329的博客
04-10 773
https://bbs.csdn.net/topics/392259288 https://blog.csdn.net/hsd2012/article/details/51208074?utm_source=blogxgwz2
java全局变量加锁_Java锁Synchronized，对象锁和类锁举例
weixin_42124743的博客
02-13 2341
4. 同步加锁的是对象，而不是代码。因此，如果你的类中有一个同步方法，这个方法可以被两个不同的线程同时执行，只要每个线程自己创建一个的该类的实例即可。5.不同的对象实例的synchronized方法是不相干扰的。也就是说，其它线程照样可以同时访问相同类的另一个对象实例中的synchronized方法。6. synchronized关键字是不能继承的，也就是说，基类的方法synchronized ...
pthread_mutex_unlock()出错
柳鲲鹏
03-02 5234
　　出外转了一圈，回来看到崩溃： Using host libthread_db library "/lib/x86_64-linux-gnu/libthread_db.so.1". Core was generated by `./gh_manager thread false 1'. Program terminated with signal SIGSEGV, Segmentation ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值