c++互斥锁，竞争状态与临界区

已于 2025-05-02 21:52:32 修改
阅读量368 收藏 6
点赞数 7
分类专栏： c++并发编程 文章标签： c++ 开发语言
于 2025-05-01 00:58:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_72753035/article/details/147641955
版权

竞争状态与临界区

1，基本互斥锁

//互斥锁使用
#include<mutex>
static  mutex  mux;
mux.lock();
mux.unlock();

案例

// An highlighted block
#include<iostream>
#include<thread>
#include<string>
#include<windows.h>
#include<chrono>
#include<mutex>
using namespace std;
static  mutex  mux;

void  TestThread1()
{
	mux.lock();
	cout << "=====================================" << endl;
	cout << "test 001" << endl;
	cout << "test 002" << endl;
	cout << "test 003" << endl;
	cout << "=====================================" << endl;
	mux.unlock();
	std::this_thread::sleep_for(std::chrono::milliseconds(50));
}

void deal1()
{
    thread  th(TestThread1);
    th.join();
}

int  main()
{
	deal1();
}

运行结果
在这里插入图片描述
互斥锁的作用在于可以尽可能的避免数据竞争，在lock与unlock之间的区域被称之为临界区，要注意一点的是，临界区要尽量小，锁要尽早的申请且尽早的释放。

2，try_lock

if (!mux.try_lock())
	{

	}
//尝试去锁，成功返回true，失败返回false

案例：

#include<windows.h>
#include<chrono>
#include<mutex>
using namespace std;
static  mutex  mux;

void  TestThread1()
{
	for (;;)
	{
		if (!mux.try_lock())
		{
			cout << "." << "flush" << endl;;
			this_thread::sleep_for(std::chrono::milliseconds(50));
			continue;
		}
		
		//mux.lock();
		cout << "=====================================" << endl;
		cout << "test 001" << endl;
		cout << "test 002" << endl;
		cout << "test 003" << endl;
		cout << "=====================================" << endl;
		mux.unlock();
		std::this_thread::sleep_for(std::chrono::milliseconds(50));
	}
	
}

void  deal1()
{
	for (int i = 0;i<10;i++)
	{
		thread  th1(TestThread1);
		th1.detach();
	}
	getchar();
}
int  main()
{
	deal1();
}

注意，try_lock有性能开销。

3，互斥锁存在的坑—线程抢占不到资源

在2节中，unlock之后选择让线程睡眠50毫秒，为什么要要sleep 50毫秒呢？？？这就涉及到多线程并发时因多线程竞争cpu资源而容易出现的坑。

线程有这样几种状态，
1，初始化（Init）: 表示该线程正在创建。
2，就绪（Ready）：表示该线程在就绪列表中，等待CPU调度。
3，运行（Running）: 表示该线程正在运行。
4，阻塞（Blocked）：该线程被阻塞挂起，包括，锁，事件，信号量阻塞。此状态不占用cpu资源
5，退出：该线程结束，等待父线程回收资源。

在这里插入图片描述
一个线程在创建，就绪之后，肯直接进入阻塞状态，也可能先进入运行状态，后进入阻塞状态。当由运行状态进入阻塞状态之后，线程在阻塞一段时间之后可能因为等待互斥锁或条件变量，重新进入就绪态，等待cpu调度之后，才再次进入运行状态。

实际上，多线程并发运行，在某一个时间段之内其实只有一个线程在占用cpu资源，当某一个线程调用unlock之后，所有线程会再次去争夺cpu资源，此时会出现一个神奇的现象，那就是，某一个线程在unlock之后，cpu资源被释放，然后多个线程再次竞争cpu资源的时候，上一个占用cpu资源的线程再次获取到了cpu资源，导致某一个线程长期能抢占到cpu资源而其他线程就无法顺利运行下去，这种情况是我们在实际的项目当中不想遇到的，于是乎，在调用unlock之后，让现场 sleep 一段事件，这样就可以让其他线程争夺cpu资源，就不会出现某一个线程长期占用cpu资源的场景了。

4，超时锁

static timed_mutex  tmux;
if (!!tmux.try_lock_for(chrono::milliseconds(500)))
	{

	}
//尝试获取锁，当五百毫秒内没有获取到锁资源，就会返回false

案例：

#include<iostream>
#include<thread>
#include<string>
#include<windows.h>
#include<chrono>
#include<mutex>
using namespace std;
static timed_mutex  tmux;

void  ThewadMain(int i)
{
	for (;;)
	{
		if (!tmux.try_lock_for(chrono::milliseconds(500)))
		{
			cout << i << "  lock failed " << endl;
			continue;
		}
		else
		{
			cout << i << " [in]" << endl;
			tmux.unlock();
			std::this_thread::sleep_for(chrono::microseconds(2000));
		}
	}
}

void  deal1()
{
	for (int i = 0; i < 3; i++)
	{
		thread th(ThewadMain,i);
		th.detach();
	}
}

int  main()
{
	deal1();
	getchar();
}

运行结果：
在这里插入图片描述

5，递归锁（在一个线程内可以多次lock的锁）recursive_mutex和recursive_timed_mutex用于业务组合

在我们开发某个项目的时候，随着时间的推移，项目代码越来越多，接口越来越多，会出现大量的接口层层调用的情况，肯会出现的一个情况是，某个外部接口已经对某个锁进行了 lock 但是调用的两一个接口也对某一个锁进行了lock ，同一个锁在同一个线程内连续调用两次lock会发生什么现象呢？

// An highlighted block
#include<iostream>
#include<thread>
#include<string>
#include<windows.h>
#include<chrono>
#include<mutex>
using namespace std;
static mutex  mux;


void Task1()
{
	mux.lock();
	cout << "task1" << endl;
	mux.unlock();
}


void  Task2()
{
	mux.lock();
	cout << "task2" << endl;
	mux.unlock();
}


void  ThewadMain(int i)
{
	mux.lock();
	Task1();
	Task2();
	mux.unlock();
}

void  deal1()
{
	thread th1(ThewadMain,1);
}

int  main()
{
	deal1();
	getchar();
}

在这里插入图片描述
我们发现，程序直接崩溃无法运行。
为了解决这个问题我们引入了递归锁，所谓的递归锁就是可以在一个线程中锁多次。

static recursive_mutex  rmux;

#include<iostream>
#include<thread>
#include<string>
#include<windows.h>
#include<chrono>
#include<mutex>

using namespace std;
static recursive_mutex  rmux;

void Task1()
{
	rmux.lock();
	cout << "task1" << endl;
	rmux.unlock();
}


void  Task2()
{
	rmux.lock();
	cout << "task2" << endl;
	rmux.unlock();
}


void  ThewadMain(int i)
{
	rmux.lock();
	Task1();
	Task2();
	rmux.unlock();
}

void  deal1()
{
	thread th1(ThewadMain,1);
	th1.detach();
}

int  main()
{
	deal1();
	getchar();
}

在这里插入图片描述
递归锁可以多次lock，但是也要相应的进行多次unlock，比如我lock两次，那么我也要相应的unlock两次。

6，利用栈特性自动释放锁RALL

RALL c++之父提出，使用局部对象来管理资源的技术成为资源获取即初始化，它的生命周期是由操作系统来管理的，无需人工介入；资源的销毁容易忘记，造成死锁或内存泄露。

简单来说就是，我们自己管理锁需要手动 lock 或者 手动 unlock ,但是随着项目周期的拉长我们很可能忘记 unlock 造成死锁，此时我们用一种方法可以不用手动实现 lock unlock 即可实现自动释放，尽可能的避免死锁或内存泄露。

6.1手动实现简易RALL

#include<iostream>
#include<thread>
#include<string>
#include<windows.h>
#include<chrono>
#include<mutex>

using namespace std;
static mutex  rmux;


class  XMutex
{
public:
	XMutex(mutex& mux):mux_(mux)
	{
		mux_.lock();
	}
	~XMutex()
	{
		mux_.unlock();
	}
private:
	mutex& mux_;
};

void  ThreadMain(int i)
{
	XMutex  lock(rmux);
	cout << i<<" in thread" << endl;
}


void  deal1()
{
	for (int i = 0; i < 10; i++)
	{
		thread th(ThreadMain,i);
		th.detach();
	}
}


int  main()
{
	deal1();
	getchar();
}

在这里插入图片描述

6.2 c++11支持的RALL管理互斥资源 lock_guard

// A code block
static mutex  rmux;
lock_guard<mutex> lock(rmux);

#include<iostream>
#include<thread>
#include<string>
#include<windows.h>
#include<chrono>
#include<mutex>
using namespace std;
static mutex  rmux;

void  ThreadMain(int i)
{
	{
		lock_guard<mutex> lock(rmux);
		cout << i << " in thread" << endl;
	}
	std::this_thread::sleep_for(chrono::microseconds(200));
	
}


void  deal1()
{
	for (int i = 0; i < 10; i++)
	{
		thread th(ThreadMain,i);
		th.detach();
	}
}


int  main()
{
	deal1();
	getchar();
}

如上述代码所示，当出了大括号的范围，自动调用析构函数，会自动进行unlock，。

6.3 c++11 unique_lock c++11

上一个小结的 lock_guard 是一个最基本的简单的 RALL 锁，但实际的项目开发过程会出现更复杂的业务需求，比如会存在 一个锁赋值给另一个锁，一个锁移动到另一个锁，或者可能会出现临时手动解锁加锁，或者其他更复杂的需求，此时我们就会使用 unique_lock 。

// A code block
unique_lock  c++11  
支持临时释放锁 unlock
支持 adopt_lock (已经拥有锁，不加锁，出栈区会释放)
支持 defer_lock (延后拥有，不加锁，出栈区不释放)
支持 try_to_lock 尝试获得互斥的所有权而不阻塞，获取失败推出栈区不会释放，通过 owns_lock() 函数判断。

// An highlighted block
#include<iostream>
#include<thread>
#include<string>
#include<windows.h>
#include<chrono>
#include<mutex>
using namespace std;
static mutex  rmux;

void  ThreadMain(int i)
{
	{
		unique_lock<mutex> lock(rmux);
		cout << i << " in thread" << endl;
	}
	std::this_thread::sleep_for(chrono::microseconds(200));
	
}


void  deal1()
{
	for (int i = 0; i < 10; i++)
	{
		thread th(ThreadMain,i);
		th.detach();
	}
}


int  main()
{
	deal1();
	getchar();
}

支持临时释放锁

// An highlighted block
void  ThreadMain(int i)
{
	{
		unique_lock<mutex> lock(rmux);
		lock.unlock();
		cout << i << " in thread" << endl;
		lock.lock();
	}
	std::this_thread::sleep_for(chrono::microseconds(200));
}
C++多线程 互斥锁 信号量 事件 临界区
小乌龟的博客
05-14 3549
一、互斥锁1、先熟悉熟悉API1，创建互斥锁，并反正一个句柄 HANDLE CreateMutex( LPSECURITY_ATTRIBUTESlpMutexAttributes, // 指向安全属性的指针 BOOLbInitialOwner, // 初始化互斥对象的所有者，一般设置为FALSE LPCTSTRlpName // 互斥对象名 );2，释放互斥对象的控制权 BOOL ReleaseMu
线程,互斥锁，临界区
li1829146612的博客
11-22 1165
1.线程概念 2.windows的线程和linux的线程的区别 3虚拟地址到地址空间的转换 4.线程优缺点 1.优点 2.缺点 5.进程控制 1.创建线程 2.线程出现异常了怎么办？进程健壮性问题 3.join的第二参数如何理解 4.线程终止时 6.如果理解pthread_t 7.三个概念 6.互斥锁 1.关于临界区的一点问题 1.我们临界资源对应的临界区被锁了，可以被切换吗？ 2.加锁完后线程被切换会怎么样？ 2.线程加锁和解锁具有原子性如何实现？ 1.了解概念 2.第一种情况 3.第二种情况 3.解锁
C++多线程同步，互斥锁、临界区、信号量比较
weixin_38834817的博客
08-25 410
程序员在日常开发中，对个多线程可能会同时访问的资源或同时执行的代码，需要进行特殊处理，包括加锁、设置临界区、信号量等。这里对互斥锁和临界区信号量做一个对比介绍。
C++ 互斥锁、自旋锁和原子操作
qq_50373827的博客
10-02 1530
目的：用于保护临界区，确保同一时刻只有一个线程可以访问共享资源。适合对复杂数据结构的保护。优点简单易用，符合 RAII 原则，确保资源的自动释放。能够处理复杂的线程同步场景。缺点可能导致上下文切换，增加开销。在高竞争情况下，线程可能会被阻塞，影响程序的响应性。使用场景：适合保护对复杂数据结构的操作，或者临界区较长的场景。
C++ 互斥锁原理以及实际使用介绍
Bobowen的博客
04-22 3469
今天带来实际开发中都需要使用的互斥锁的内容，主要聊一聊如何使用互斥锁以及都有哪几种方式实现互斥锁。实现互斥，可以有以下几种方式：互斥量（Mutex）、递归互斥量（Recursive Mutex）、读写锁（Read-Write Lock）、条件变量（Condition Variable）。 互斥锁保证了计算机资源访问的安全，互斥锁的不当使用同时也加大了程序阻塞的风险。提前祝大家五一前工作生活学习一切顺利。
C++ 互斥锁的使用
2301_79881188的博客
02-22 914
std::mutex 是C++标准库中用于线程同步的互斥锁机制，主要用于保护共享资源，避免多个线程同时访问导致的竞态条件。lock：阻塞当前线程，直到获取锁。unlock：释放锁，允许其他线程获取锁。try_lock：尝试获取锁，如果锁已被占用则立即返回。
C++互斥锁：确保线程安全的利器
至虛極，守靜篤
12-02 696
互斥锁（Mutex，全称Mutual Exclusion）是一种用于保护共享资源，防止多个线程同时访问该资源的同步机制。当一个线程获取到互斥锁后，其他尝试获取该锁的线程将被阻塞，直到锁被释放为止。这样，就可以确保在同一时间内只有一个线程能够访问共享资源，从而避免数据竞争和不一致的问题。
c++ 互斥锁使用详解 lock_guard
luohaha66的博客
11-03 448
【代码】c++ 互斥锁使用详解 lock_guard。
C++多线程编程(2) -- 互斥锁 信号量 事件 临界区
qq_34462436的博客
09-21 665
一、互斥锁 1、先熟悉熟悉API 1，创建互斥锁，并反正一个句柄 HANDLE CreateMutex( LPSECURITY_ATTRIBUTESlpMutexAttributes, // 指向安全属性的指针 BOOLbInitialOwner, // 初始化互斥对象的所有者，一般设置为FALSE LPCTSTRlpName // 互斥对象名 ); 2，释放互斥对象的控制权 BOO...
C++封装互斥锁_互斥锁 用在类中 c++
m0_61499908的博客
01-11 632
这将是开发工程师的梦魇！？C++利用了一个非常好的特性：当一个对象初始化时自动调用构造函数，当一个对象到达其作用域结尾时，自动调用析构函数。所以我们可以利用这个特性解决锁的维护问题：把锁封装在对象内部！此时，在构造函数时获得锁，在语句返回前自动调用析构函数释放锁。其实这种做法有个专有的名称，叫做RAII（Resource Acquisition Is Initialization）
C++多线程互斥锁与临界区实现及其特点
本文档主要探讨了多线程编程中两种关键的同步机制：互斥锁（Mutex）和临界区锁（CriticalSection），并提供了相关的C++实现代码。这两种机制在并发控制中起着至关重要的作用，确保了多个线程之间的数据访问安全性和...
Windows c++ 互斥量 信号量 临界区
Usuitakumi的博客
12-06 1433
跟信号量/互斥量等相关的其实有两部分，一个是共享的资源，另外一个是操作的顺序。如果一开始操作的顺序没有规定下来的话，正确结果也不会确定，利用信号量等工具保证结果准确也失去了前提。
C++互斥锁源码分析与演示程序
在C++中，互斥锁（Mutex...了解和掌握了以上关于C++互斥锁的知识，可以帮助开发者编写出更加健壮和高效的多线程程序。在实际开发中，应当根据程序的具体需求选择合适的互斥锁类型，并合理管理锁的生命周期和访问策略。
std::print 和 std::println
janeqi1987的专栏
04-28 1019
std::print和是 C++23 新增的格式化输出函数，旨在替代传统的std::cout链式调用。它们基于实现，支持类型安全的格式化字符串，语法更简洁，性能更优15。直接输出到stdout（默认）或指定的流。自动在输出末尾添加换行符。支持与相同的格式化语法（如{}占位符）。
深入理解C语言中的整形提升与算术转换
qinyuz的博客
05-01 591
在C语言中，整形提升（Integer Promotion）是一个重要但容易被忽视的概念。它指的是在表达式中，任何小于。是无符号char，赋值-1会转换为255（0xFF）长度为标准操作数长度，使用标准长度可以提高运算效率。都是有符号char，值为-1（内存表示：0xFF）：符号扩展为0xFFFFFFFF（即-1）：零扩展为0x000000FF（即255））操作数在使用前都会被自动转换为普通整型。：确保不同大小的整型在运算时有一致的表现。有符号类型：高位补符号位。无符号类型：高位补0。是2字节，所以前两个。
STL之list容器
Laydya的博客
05-03 756
1.list的底层是双向链表结构，双向链表中的每个元素在互不相关的独立结点中，在结点中通过指针指向前一个元素和后一个元素2.list是可以在常数范围内在任意位置的插入和删除的序列式容器，并且该容器可以前后双向迭代3.vector的优点：支持随机访问，间接的就支持了排序/二分查找/堆排序等缺点：1.头部和中部的插入效率低，需要挪动数据2.插入数据空间不够需要增容，增容需要开新空间，拷贝数据，释放旧空间list的优点：没有增容代价，且任意位置插入都是0（1）；
STL之vector容器
Laydya的博客
05-02 1078
1.vector是可变大小数组的容器2.像数组一样，采用连续的空间存储，也就意味着可以通过下标去访问，但它的大小可以动态改变3.每次的插入都要开空间吗？开空间就要意味着先开临时空间，然后在拷贝旧的到新的上面，在释放原来的，就时间而言，这是一个相对代价很高的任务；显然这是不行的，vector的分配策略：会分配一些而外的空间以适应可能的增长，例如我们平时说的以1.5或者2倍的方式增容，不同的库选择不同的策略权衡空间的使用和重新分配，以至于在插入一个元素时能在常数时间内插入；
游戏代码C
最新发布
2301_81771576的博客
05-03 293
以下将结合不同编程语言的特点及游戏开发中的实际应用，展示多种语言的游戏代码示例（以简单游戏为例，展示代码结构和逻辑差异）。3. Python/JavaScript/Lua：语法简洁，适合快速开发，代码量最少。Unity引擎集成度高，C#代码简洁但功能强大，适合快速开发跨平台游戏。1. C++：需手动管理资源（如字体加载），代码行数最多但性能最优。Lua语法极简，常用于游戏逻辑脚本（如《魔兽世界》插件）。1. C# + Unity（面向对象，适合跨平台开发）Python语法简洁，适合快速验证游戏逻辑。
第十一届蓝桥杯 2020 C/C++组 门牌制作
2301_80558092的博客
05-01 482
简单的数位切分问题，循环让i从1遍历到2020，每次定义临时变量temp存储i的值，每次通过temp%10取当前temp的最后一位，再通过temp/=10去掉当前temp的最后一位。把每次取的数位判断是否为2，把temp切到0就代表全部数位都切分出来了
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值