互斥锁 形成死锁实例

#include <iostream>
#include <mutex>
#include <thread>

std::mutex coutMutex;

int main(){

    std::thread t([]{
                      std::cout << "Still waiting ..." << std::endl;
                      std::lock_guard<std::mutex> lockGuard(coutMutex);
                      std::cout << std::this_thread::get_id() << std::endl;
                  }
    );

    {
        std::lock_guard<std::mutex> lockGuard(coutMutex);
        std::cout << std::this_thread::get_id() << std::endl;
        t.join();
    }

}

lock_guard 相当于 lock 和 unlock,在代码段结束或者函数结束时unlock,因此在主线程中已经对 std::cout 流进行了加锁,在代码段输出 “Still Waiting” 后,尝试对std::cout 进行加锁时,会导致失败,等待资源。
改进措施:

{
  t.join();
  std::lock_guard<std::mutex> lockGuard(coutMutex);
  std::cout << std::this_thread::get_id() << std::endl;
}
{
  {
    std::lock_guard<std::mutex> lockGuard(coutMutex);
    std::cout << std::this_thread::get_id() << std::endl;
  }
  t.join();
}

英文博客地址 : https://www.modernescpp.com/index.php/prefer-locks-to-mutexes
lock_guard 和 unique_guard 的讲解:https://www.jianshu.com/p/34d219380d90

原文地址:https://www.cnblogs.com/walnuttree/p/10690025.html

时间: 2024-10-20 04:59:41

互斥锁 形成死锁实例的相关文章

解决NSDistributedLock进程互斥锁的死锁问题(一)

在MAC下的多进程开发中,NSDistributedLock是一个非常方便的互斥锁解决方案,一般的使用方法: 12345678 NSDistributedLock *lock = [[NSDistributedLock alloc] initWithPath:@"/Users/mac/Desktop/lock.lock"];while (![lock tryLock]){ sleep(1);} //do something[lock unlock]; 但在实际使用过程中,当执行到do

解决NSDistributedLock进程互斥锁的死锁问题(二)

上一篇文章中介绍了采用了文件记录锁来实现更加安全的多进程互斥,它的平台兼容性也非常好,并且我们也采用它实现了NSDistributedLock的所有的方法.其实在OSX还可以采用文件读写锁来实现更加方便的进程互斥,在fcntl.h中我们可以看到这样的宏定义: 123 #if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)#define O_SHLOCK 0x0010 /* open with shared file lock */#d

Python36 1.joinablequeue 2.线程理论 3.多线程对比多进程 4.线程的使用方式 4.1.产生 线程的两种方式 4.2.守护线程 4.3.线程安全问题 4.3.1.互斥锁 4.3.2.死锁 4.3.3.可重入锁 4.3.4.信号量

复习1.守护进程2.互斥锁(解决数据错乱的方法)3.IPC(进程间通讯)4.生产者与消费者模型 详解:1.守护进程 一个进程可以设为另一个进程的守护进程 特点:被守护的进程结束时,守护进程也会随之结束 本质:父进程交给子进程一个任务,然而父进程 先于子进程结束了,子进程的任务也就没有必要 继续执行了 格式:开始前加 p.daemon=True 2.互斥锁(解决数据错乱的方法)方法一:互斥锁 互斥 互相排斥 锁的本质:一个标志 标志的两个状态: 1.锁定 2.未锁定 什么时候用? 当多个进程要操作

C11线程管理:互斥锁

1.概述 锁类型 c11提供了跨平台的线程同步手段,用来保护多线程同时访问的共享数据. std::mutex,最基本的 Mutex 类,独占的互斥量,不能递归使用. std::time_mutex,带超时的独占互斥量,不能递归使用. std::recursive_mutex,递归互斥量,不带超时功能. std::recursive_timed_mutex,带超时的递归互斥量. lock类型 std::lock_guard,与 Mutex RAII 相关,方便线程对互斥量上锁. std::uniq

python线程互斥锁Lock(29)

在前一篇文章 python线程创建和传参 中我们介绍了关于python线程的一些简单函数使用和线程的参数传递,使用多线程可以同时执行多个任务,提高开发效率,但是在实际开发中往往我们会碰到线程同步问题,假如有这样一个场景:对全局变量累加1000000次,为了提高效率,我们可以使用多线程完成,示例代码如下: # !usr/bin/env python # -*- coding:utf-8 _*- """ @Author:何以解忧 @Blog(个人博客地址): shuopython

Mutex互斥锁的使用方法

同一时刻,只能有一个线程持有该锁! 使用Mutex互斥锁来同步两个单独的程序(可以两次运行该程序,查看运行结果) static void Main(string[] args) { const string MutexName = "CSharpThreadingCookbook"; using (var m = new Mutex(false, MutexName)) { //WaitOne构造表示指定的时间内(这里是5秒)是否可以获得互斥锁定 if (!m.WaitOne(Time

iOS并发编程笔记,包含GCD,Operation Queues,Run Loops,如何在后台绘制UI,后台I/O处理,最佳安全实践避免互斥锁死锁优先级反转等,以及如何使用GCD监视进程文件文件夹,并发测试的方案等

iOS并发编程笔记,包含GCD,Operation Queues,Run Loops,如何在后台绘制UI,后台I/O处理,最佳安全实践避免互斥锁死锁优先级反转等,以及如何使用GCD监视进程文件文件夹,并发测试的方案等 线程 使用Instruments的CPU strategy view查看代码如何在多核CPU中执行.创建线程可以使用POSIX 线程API,或者NSThread(封装POSIX 线程API).下面是并发4个线程在一百万个数字中找最小值和最大值的pthread例子: #import

一种有效避免死锁的互斥锁设计

下面是摘自网络的一段话,我觉得很好:对认识锁很有帮助. "为什么要加锁?加锁是为了防止不同的线程访问同一共享资源造成混乱. 打个比方:人是不同的线程,卫生间是共享资源. 你在上洗手间的时候肯定要把门锁上吧,这就是加锁,只要你在里面,这个卫生间就被锁了,只有你出来之后别人才能用.想象一下如果卫生间的门没有锁会是什么样? 什么是加锁粒度呢?所谓加锁粒度就是你要锁住的范围是多大. 比如你在家上卫生间,你只要锁住卫生间就可以了吧,不需要将整个家都锁起来不让家人进门吧,卫生间就是你的加锁粒度. 怎样才算合

死锁现象与解决方案,开启线程的2种方式,守护线程,线程VS进程,线程互斥锁,信号量

死锁现象与解决方案 from threading import Thread,Lock,active_count import time mutexA=Lock() # 锁1 mutexB=Lock() # 锁2 class Mythread(Thread): def run(self): self.f1() self.f2() def f1(self): mutexA.acquire() print('%s 拿到A锁' %self.name) mutexB.acquire() print('%