互斥锁和条件变量的性能

最新推荐文章于 2025-10-09 13:28:09 发布
原创 最新推荐文章于 2025-10-09 13:28:09 发布 · 611 阅读 · 3 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#多线程 #操作系统

介绍

本文以最简单生产者消费者模型，通过运行程序，观察该进程的cpu使用率，来对比使用互斥锁 和 互斥锁+条件变量的性能比较。

本例子的生产者消费者模型，1个生产者，5个消费者。
生产者线程往队列里放入数据，5个消费者线程从队列取数据，取数据前需要判断一下队列中是否有数据，这个队列是全局队列，是线程间共享的数据，所以需要使用互斥锁进行保护。即生产者在往队列里放入数据时，其余消费者不能取，反之亦然。

互斥锁实现的代码

#include <iostream> // std::cout
#include <deque>    // std::deque
#include <thread>   // std::thread
#include <chrono>   // std::chrono
#include <mutex>    // std::mutex


// 全局队列
std::deque<int> g_deque;

// 全局锁
std::mutex g_mutex;

// 生产者运行标记
bool producer_is_running = true;

// 生产者线程函数
void Producer()
{
	// 库存个数
    int count = 8;
    
    do
    {
		// 智能锁，初始化后即加锁，保护的范围是代码花括号内，花括号退出即会自动解锁
		// 可以手动解锁，从而控制互斥锁的细粒度
        std::unique_lock<std::mutex> locker( g_mutex );
		// 入队一个数据
        g_deque.push_front( count );
		// 提前解锁，缩小互斥锁的细粒度，只针对共享的队列数据进行同步保护
        locker.unlock(); 

        std::cout << "生产者    ：我现在库存有 :" << count << std::endl;
			
		// 放慢生产者生产速度，睡1秒
        std::this_thread::sleep_for( std::chrono::seconds( 1 ) );

        // 库存自减少
        count--;
    } while( count > 0 );
	
	// 标记生产者打样了
	producer_is_running = false;

	std::cout << "生产者    ： 我的库存没有了，我要打样了！"  << std::endl;
}

// 消费者线程函数
void Consumer(int id)
{
    int data = 0;

    do
    {
        std::unique_lock<std::mutex> locker( g_mutex );
        if( !g_deque.empty() )
        {
            data = g_deque.back();
            g_deque.pop_back();
            locker.unlock();

            std::cout << "消费者[" << id << "] : 我抢到货的编号是 :" << data << std::endl;
        }
        else
        {
            locker.unlock();
        }
    } while( producer_is_running );
	
	std::cout << "消费者[" << id << "] ：卖家没有货打样了，真可惜，下次再来抢！"  << std::endl;
}

int main(void)
{
    std::cout << "1 producer start ..." << std::endl;
    std::thread producer( Producer );

    std::cout << "5 consumer start ..." << std::endl;
    std::thread consumer[ 5 ];
    for(int i = 0; i < 5; i++)
    {
        consumer[i] = std::thread(Consumer, i + 1);
    }

    producer.join();

    for(int i = 0; i < 5; i++)
    {
        consumer[i].join();
    }

    std::cout << "All threads joined." << std::endl;

    return 0;
}
互斥锁实现运行结果：

结果输出

[root@lincoding condition]# g++ -std=c++0x -pthread -D_GLIBCXX_USE_NANOSLEEP main.cpp -o  main
[root@lincoding condition]# ./main
1 producer start ...
5 consumer start ...
生产者    ：我现在库存有 :8
消费者[1] : 我抢到货的编号是 :8
消费者[1] : 我抢到货的编号是 :7
生产者    ：我现在库存有 :7
生产者    ：我现在库存有 :6
消费者[3] : 我抢到货的编号是 :6
生产者    ：我现在库存有 :5
消费者[1] : 我抢到货的编号是 :5
生产者    ：我现在库存有 :4
消费者[2] : 我抢到货的编号是 :4
生产者    ：我现在库存有 :3
消费者[5] : 我抢到货的编号是 :3
生产者    ：我现在库存有 :2
消费者[2] : 我抢到货的编号是 :2
生产者    ：我现在库存有 :1
消费者[1] : 我抢到货的编号是 :1
生产者    ： 我的库存没有了，我要打样了！消费者[
5] ：卖家没有货打样了，真可惜，下次再来抢！
消费者[2] ：卖家没有货打样了，真可惜，下次再来抢！
消费者[3] ：卖家没有货打样了，真可惜，下次再来抢！
消费者[4] ：卖家没有货打样了，真可惜，下次再来抢！
消费者[1] ：卖家没有货打样了，真可惜，下次再来抢！
All threads joined.

可以看到，互斥锁其实可以完成这个任务，但是却存在着性能问题。

  • Producer是生产者线程，在生产者数据过程中，会休息1秒，所以这个生产过程是很慢的；

  • Consumer是消费者线程，存在着一个while循环，只有判断到生产者不运行了，才会退出while循环，那么每次在循环体内，都是会先加锁，判断队列不空，然后从列队取出一个数据，最后解锁。所以说，在生产者休息1秒的时候，消费者线程实际上会做很多无用功，导致CPU使用率非常高！

运行的环境是4核cpu

[root@lincoding ~]# grep 'model name' /proc/cpuinfo | wc -l
4

top命令查看cpu使用情况，可见使用纯互斥锁cpu的开销是很大的，main进程的cpu使用率达到了357.5%CPU，系统开销的cpu为54.5%sy，用户开销的cpu为18.2%us

[root@lincoding ~]# top
top - 19:13:41 up 36 min,  3 users,  load average: 0.06, 0.05, 0.01
Tasks: 179 total,   1 running, 178 sleeping,   0 stopped,   0 zombie
Cpu(s): 18.2%us, 54.5%sy,  0.0%ni, 27.3%id,  0.0%wa,  0.0%hi,  0.0%si,  0.0%st
Mem:   1004412k total,   313492k used,   690920k free,    41424k buffers
Swap:  2031608k total,        0k used,  2031608k free,    79968k cached

PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND
35346 root 20 0 137m 3288 1024 S 357.5 0.3 0:05.92 main
1 root 20 0 19232 1492 1224 S 0.0 0.1 0:02.16 init
2 root 20 0 0 0 0 S 0.0 0.0 0:00.01 kthreadd
3 root RT 0 0 0 0 S 0.0 0.0 0:00.68 migration/0

解决的办法之一就是给消费者也加一个小延时，当消费者没取到数据时，就休息一下500毫秒，这样可以减少互斥锁给cpu带来的开销。

// 消费者线程函数
void Consumer(int id)
{
    int data = 0;

    do
    {
        std::unique_lock<std::mutex> locker( g_mutex );
        if( !g_deque.empty() )
        {
            data = g_deque.back();
            g_deque.pop_back();
            locker.unlock();

            std::cout << "消费者[" << id << "] : 我抢到货的编号是 :" << data << std::endl;
        }
        else
        {
            locker.unlock();
            // 当消费者没取到数据时，就休息一下500毫秒
			std::this_thread::sleep_for( std::chrono::milliseconds( 500 ) );
        }
    } while( producer_is_running );
	
	std::cout << "消费者[" << id << "] ：卖家没有货打样了，真可惜，下次再来抢！"  << std::endl;
}

从运行结果可知，cpu使用率大大降低了

[root@lincoding ~]# ps aux | grep -v grep  |grep main
USER        PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root      61296  0.0  0.1 141068  1244 pts/1    Sl+  19:40   0:00

条件变量+互斥锁实现的代码
那么问题来了，如何确定消费者延时（休息）多久呢？

如果生产者生产的非常快，消费者却延时了500毫秒，也不是很好
如果生产者生产的更慢，那么消费延时500毫秒，也会有无用功，占用了CPU
这就需要引入条件变量std::condition_variable，应用于消费者生产模型中，就是生产者生产完一个数据后，通过notify_one()唤醒正在wait()消费者线程，使得消费者从队列取出一个数据。

#include <iostream> // std::cout
#include <deque>    // std::deque
#include <thread>   // std::thread
#include <chrono>   // std::chrono
#include <mutex>    // std::mutex

#include <condition_variable> // std::condition_variable


// 全局队列
std::deque<int> g_deque;

// 全局锁
std::mutex g_mutex;

// 全局条件变量
std::condition_variable g_cond;

// 生产者运行标记
bool producer_is_running = true;

// 生产者线程函数
void Producer()
{
	// 库存个数
    int count = 8;
    
    do
    {
		// 智能锁，初始化后即加锁，保护的范围是代码花括号内，花括号退出即会自动解锁
		// 可以手动解锁，从而控制互斥锁的细粒度
        std::unique_lock<std::mutex> locker( g_mutex );
		// 入队一个数据
        g_deque.push_front( count );
		// 提前解锁，缩小互斥锁的细粒度，只针对共享的队列数据进行同步保护
        locker.unlock(); 

        std::cout << "生产者    ：我现在库存有 :" << count << std::endl;
		
		// 唤醒一个线程
		g_cond.notify_one();
		
		// 睡1秒
        std::this_thread::sleep_for( std::chrono::seconds( 1 ) );

        // 库存自减少
        count--;
    } while( count > 0 );
	
	// 标记生产者打样了
	producer_is_running = false;
	
	// 唤醒所有消费线程
	g_cond.notify_all();
	
	std::cout << "生产者    ： 我的库存没有了，我要打样了！"  << std::endl;
}

// 消费者线程函数
void Consumer(int id)
{
	// 购买的货品编号
    int data = 0;

    do
    {
		// 智能锁，初始化后即加锁，保护的范围是代码花括号内，花括号退出即会自动解锁
		// 可以手动解锁，从而控制互斥锁的细粒度
        std::unique_lock<std::mutex> locker( g_mutex );
		
		// wait()函数会先调用互斥锁的unlock()函数，然后再将自己睡眠，在被唤醒后，又会继续持有锁，保护后面的队列操作
		// 必须使用unique_lock，不能使用lock_guard，因为lock_guard没有lock和unlock接口，而unique_lock则都提供了
		g_cond.wait(locker); 
		
		// 队列不为空
        if( !g_deque.empty() )
        {
			// 取出队列里最后一个数据
            data = g_deque.back();
			
			// 删除队列里最后一个数据
            g_deque.pop_back();
			
			// 提前解锁，缩小互斥锁的细粒度，只针对共享的队列数据进行同步保护
            locker.unlock(); 

            std::cout << "消费者[" << id << "] : 我抢到货的编号是 :" << data << std::endl;
        }
		// 队列为空
        else
        {
            locker.unlock();
        }
	
    } while( producer_is_running );
	
	std::cout << "消费者[" << id << "] ：卖家没有货打样了，真可惜，下次再来抢！"  << std::endl;
}

int main(void)
{
    std::cout << "1 producer start ..." << std::endl;
    std::thread producer( Producer );

    std::cout << "5 consumer start ..." << std::endl;
    std::thread consumer[ 5 ];
    for(int i = 0; i < 5; i++)
    {
        consumer[i] = std::thread(Consumer, i + 1);
    }

    producer.join();

    for(int i = 0; i < 5; i++)
    {
        consumer[i].join();
    }

    std::cout << "All threads joined." << std::endl;

    return 0;
}
条件变量+互斥锁运行结果
[root@lincoding condition]# g++ -std=c++0x -pthread -D_GLIBCXX_USE_NANOSLEEP main.cpp -o  main
[root@lincoding condition]# 
[root@lincoding condition]# ./main 
1 producer start ...
5 consumer start ...
生产者    ：我现在库存有 :8
消费者[4] : 我抢到货的编号是 :8
生产者    ：我现在库存有 :7
消费者[2] : 我抢到货的编号是 :7
生产者    ：我现在库存有 :6
消费者[3] : 我抢到货的编号是 :6
生产者    ：我现在库存有 :5
消费者[5] : 我抢到货的编号是 :5
生产者    ：我现在库存有 :4
消费者[1] : 我抢到货的编号是 :4
生产者    ：我现在库存有 :3
消费者[4] : 我抢到货的编号是 :3
生产者    ：我现在库存有 :2
消费者[2] : 我抢到货的编号是 :2
生产者    ：我现在库存有 :1
消费者[3] : 我抢到货的编号是 :1
生产者    ： 我的库存没有了，我要打样了！
消费者[5] ：卖家没有货打样了，真可惜，下次再来抢！
消费者[1] ：卖家没有货打样了，真可惜，下次再来抢！
消费者[4] ：卖家没有货打样了，真可惜，下次再来抢！
消费者[2] ：卖家没有货打样了，真可惜，下次再来抢！
消费者[3] ：卖家没有货打样了，真可惜，下次再来抢！
All threads joined.

CPU开销非常的小

[root@lincoding ~]# ps aux | grep -v grep  |grep main
USER        PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root      73838  0.0  0.1 141068  1256 pts/1    Sl+  19:54   0:00 ./main

总结

在不确定生产者的生产速度是快还是慢的场景里，不能只使用互斥锁保护共享的数据，这样会对CPU的性能开销非常大，可以使用互斥锁+条件变量的方式，当生产者线程生产了一个数据，就唤醒消费者线程进行消费，避免一些无用功的性能开销。

Z.I.M
关注
如何实现一个比互斥锁快100倍并且消耗最少CPU的通用“锁”（1）
guijiewan的专栏
12-07 1551
多线程的基本问题 年初面试了不少移动端应用开发人员，面试过程问到一些多线程编程需要注意一些问题，主要是像考察一下对多线程安全有没有概念，因为在接手其他人的项目时一直被坑，多线程下出各种乱七八糟稳定性问题。具体问题一般就简化为两个： 1，如何实现一个线程安全的单例（singleton）。 2，有两个线程，线程1和线程2，同时对同一个变量i自加（i++）10000次，两个线程都完成退出时，变量i的值
Java中条件变量使用示例及性能测试
runyon的博客
10-10 486
和前篇文章一样的目的，测试结果也差不多，不过java中的条件变量效率略高于boost，结果是每秒大概20w出头。 =================================================================================== package com.cc; public class Test {         static boole
c++多线程（6）------ 条件变量
最新发布
jndingxin的专栏
10-09 727
条件变量（Condition Variable） 是实现线程间高效等待与通知机制的核心工具，通常与互斥锁配合使用，用于解决“生产者-消费者”、“任务队列”、“线程协调”等经典并发问题。
探讨互斥锁锁定非临界区带来多少性能消耗
木牛的博客
08-29 867
概述 本次主要是测试使用互斥锁，锁定非临界区带来的性能消耗。 在我们写代码时，有时候通过逻辑的设计，可以使代码中临界区在80%以上不会同时访问。但是从理论上来说，在极端或者概率很低的情况下它是可能成为临界区的。处于程序的稳定性考虑，同样是需要加锁的。 但是最近在看disruptor文档[1]时，文献提到： 即使不是临界资源，只要调用了锁就会大幅度的降低性能。 而我之前在项目中的代码，总是会考虑逻辑上减少多线程去竞争同一个锁，这难道是在做无用功？ 文中采用的是简单的做5亿次++操作，考虑到其是用Ja
C++ 并发编程之互斥锁和条件变量的性能比较
小林coding
09-01 2248
介绍 本文以最简单生产者消费者模型，通过运行程序，观察该进程的cpu使用率，来对比使用互斥锁 和 互斥锁+条件变量的性能比较。 本例子的生产者消费者模型，1个生产者，5个消费者。 生产者线程往队列里放入数据，5个消费者线程从队列取数据，取数据前需要判断一下队列中是否有数据，这个队列是全局队列，是线程间共享的数据，所以需要使用互斥锁进行保护。即生产者在往队列里放入数据时，其余消费者不能取，反之亦然。...
互斥锁与条件变量详解
热门推荐
lwz15071387627的博客
03-04 1万+
一、互斥量和条件变量简介 　　互斥量(mutex)从本质上说是一把锁，在访问共享资源前对互斥量进行加锁，在访问完成后释放互斥量上的锁。在互斥量进行加锁以后，任何其它试图再次对互斥量加锁的线程将会阻塞直到当前线程释放该互斥锁。如果释放互斥锁时有多个线程阻塞，所有在该互斥锁上的阻塞线程都会变成可运行状态，第一个变为可运行状态的线程可以对互斥锁加锁，其它线程将会看到互斥锁依然被锁住，只能回去再次等待它...
浅谈互斥锁为什么还要和条件变量配合使用
09-15
互斥锁和条件变量是多线程编程中用于线程同步的重要工具，它们共同作用以实现高效、安全的并发操作。互斥锁确保了对共享资源的独占访问，防止了多个线程同时进入临界区，从而避免数据竞争。然而，互斥锁的局限在于它...
精选资源
多线程同步机制与生产者消费者问题的C语言实现-互斥锁、条件变量及Posix信号量的应用
01-11
接下来详细展示了两种编程实现方法，一是基于pthread库的互斥锁和条件变量，二是通过信号量机制，并给出了相应的示例程序，展示了如何创建多线程应用程序并在多核或多处理器环境下提高系统的并发性能和吞吐率。...
操作系统基于互斥锁与条件变量的线程同步机制：Linux环境下生产者-消费者模型实现及gdb调试应用
09-19
内容概要：本文深入探讨了Linux操作系统下线程同步与通信的实现机制，重点讲解了互斥锁、条件变量、信号量等核心同步工具的原理及其在多线程编程中的应用。通过生产者-消费者模型的经典案例，结合C语言和POSIX线程库...
abb输出，使用多线程配合互斥锁及条件变量来实现，C++源码演示
11-27
在C++编程中，多线程技术是一种常见的方式，用于提升程序的执行效率，...打开解决方案，查看源代码，我们可以更深入地理解多线程、互斥锁和条件变量的用法。同时，这也为我们提供了一个学习和实践多线程编程的好例子。
69、线程同步：互斥锁与条件变量详解
qsc901234的博客
10-07 16
本文深入讲解了多线程编程中的核心同步机制——互斥锁与条件变量。内容涵盖互斥锁的使用频率、性能分析、死锁问题及避免策略，详细介绍了互斥锁的动态初始化、属性设置和不同类型的应用场景。同时，文章通过生产者-消费者模型阐述了条件变量的作用，强调其在避免忙等待、实现线程间通信方面的优势，并解析了pthread_cond_wait与pthread_cond_signal的正确使用方式及注意事项。最后总结了线程同步的最佳实践，帮助开发者构建高效、稳定的多线程应用程序。
同步和异步、阻塞和非阻塞
weixin_34405925的博客
07-31 233
首先说明我对这些概念也不是很清楚，以下内容是我做的一些理事。 同步和异步、阻塞和非阻塞这是两组概念，说的是不同的事情，同步和阻塞没有必然的联系，异步和非阻塞也没有必然的联系。同步和异步是只跟IO操作过程中进程的状态变化有关。阻塞和非阻塞就是进程的两种状态。比如你去银行，排除的话就是一种同步的方式，叫号的话就是异步的方式。排队必须自己看着什么时候轮到自己，而叫号则不必，轮到你的时候会触发一个事件，...
简述python多线程中的互斥锁
feilzhang的博客
05-04 3749
        在编程中，为了保证共享数据操作的完整性，引入了互斥锁的概念。每个对象都对应于一个可称为" 互斥锁" 的标记，这个标记用来保证在任一时刻，只能有一个线程访问该对象。在python中由于多线程的存在，并且对全局变量作用时有可能产生全局变量紊乱问题，所以也加入了同步和互斥等方法，但是我们主要讲解互斥锁：如下代码定义了一个my_num的全局变量，而函数sum1和函数sum2都执行对my_n...
C++原子操作和互斥锁性能（速度）对比
崔杰城的博客
11-29 3745
执行时间是0.541秒，是耗时最短的，但是由于没有用互斥方法保护，所以临界资源n的值不正确（正确的值应该为0）。这是因为自增、自减操作不是原子的，编译得到的汇编指令可能会对应多条指令。可以看到耗时为：5.261秒，n的值为0。编写测试demo，开启两个线程，对全局变量n分别进行自增、自减操作，计算执行时间。所以对于基本类型的临界资源，我们进行访问时可以用原子操作代替互斥锁，来提高性能。执行时间最长，但也能保持临界资源n的值正确。先说结论：原子操作性能（速度）强于互斥锁，下面用例子进行说明。
不考虑多线程的情况下，互斥锁的性能
12-16 280
不考虑多线程的情况下，进出一次互斥锁的时间大概是 0.02 微秒， #include <QCoreApplication> #include<mutex> #include<chrono> #include<iostream> int main(int argc, char *argv[]) { QCoreApplication a(argc, argv); int num = 1000 * 1000 * 1000; ..
互斥量与读写锁的异同与性能分析
雪雪
05-02 1350
结论：读写锁提高了并行性，但是就速度而言并不比互斥量快，在我的系统(ubuntu12.04)从上面的输出看到读写锁比互斥量明显速度方面不足。 分析： 一、线程同步简单的说就是当多个线程共享相同的内存时，当某个线程可以修改变量，而其他线程也可以读取或修改这个变量的时候，就需要对这些线程进行同步，以确保他们在访问变量的存储内容时不会访问到无效的数值。 我们来看个上面一个对于多线程访问共享变量造成竞...
锁为什么是低效率的？
The_Old_man_and_sea的博客
06-28 2042
并发编程学习笔记学习的内容这本书讲述了什么怎样讲述的为什么要这样讲述如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 学习的内容 这系列学习笔记是基于linux ...
Linux 系统编程之条件变量
hjj1618的博客
05-31 851
使用条件变量的原因 使用条件变量的原因 如果没有条件变量，那么我们等待一个条件满足则会是下面这样的模型： 首先加锁进入临界区去查看条件是否满足，不满足则解锁离开临界区，睡眠一段时间再继续循环判断。在这种情况下如果刚离开临界区，条件变为满足，那么线程必须还要等一段时间重新进入临界区才能知道条件满足（如果在这段时间内，条件依旧一直保持满足的话），如果这一小段时间条件又变为不满足，那么这个线程还要继续循环判断。不断地加锁解锁（会影响使用同一把锁的其他线程），还不能第一时间收到条件满足。这种模型既费时又开销大。
互斥锁的缺点
weixin_33850890的博客
07-18 729
互斥锁有一些缺点：例如，如果忘记对互斥锁解除锁定，会怎么样呢？如果是这样，则试图锁定已经被锁定的互斥锁的任何进程只能永无止境地等到。这些线程就成为僵死（zombie thread），这是一个技术术语，指虽然存在但不能干任何事情的线程。显而易见，我们并不希望这种事情发生。 互斥锁还有另外一个问题，看看在下面的情况下会怎么样？ 如果两线程依赖于同一个对象（比方说游戏玩家的状态这一对象，每帧都要...
C++ 中的互斥锁和条件变量
09-11
<think> 我们正在讨论互斥锁和条件变量。首先，我需要整理用户提供的引用内容，然后结合我的知识来回答。 引用内容主要集中在互斥锁和条件变量的基础使用、常见问题、易错点以及如何避免这些问题。用户的问题是想了解C++中互斥锁和条件变量的介绍、使用方法和相关知识。 因此，我将组织以下内容： 1. 互斥锁（std::mutex）的基本介绍和使用方法 2. 条件变量（std::condition_variable）的基本介绍和使用方法 3. 互斥锁和条件变量配合使用的经典模式 4. 常见错误和注意事项 5. 示例代码 另外，根据引用中的一些要点： - 互斥锁用于保护共享资源，确保同一时间只有一个线程访问（引用[1][2][3]）。 - 条件变量用于线程间的协调，让线程在条件满足时被唤醒（引用[2][5]）。 - 使用lock_guard和unique_lock等RAII包装器可以避免忘记解锁（引用[4]）。 - 条件变量使用时有虚假唤醒的问题，所以需要在条件检查时使用循环（引用[5]）。 我将按照这些要点展开。 注意：根据系统级指令，数学表达式需要用$...$，独立公式用$$...$$，并且用中文回答。同时，在回答末尾生成相关问题。 </think> ### C++互斥锁与条件变量详解 #### 一、互斥锁(std::mutex) 互斥锁是保证线程安全的基础同步机制，确保同一时间只有一个线程访问共享资源。 **核心方法：** 1. **基础使用** ```cpp #include <mutex> std::mutex mtx; void critical_section() { mtx.lock(); // 获取锁 // 临界区代码（访问共享资源） mtx.unlock(); // 释放锁 } ``` - ️ **风险**：必须显式调用`unlock()`，异常时可能导致死锁[^4] 2. **RAII包装器（推荐）** ```cpp // lock_guard (C++11) { std::lock_guard<std::mutex> guard(mtx); // 自动加锁/解锁 } // unique_lock (C++11) { std::unique_lock<std::mutex> ulock(mtx, std::defer_lock); ulock.lock(); // 可延迟加锁 // ... } // 自动解锁 ``` - ✅ **优势**：异常安全，避免忘记解锁[^2][^4] - 🔍 **区别**：`unique_lock`支持转移所有权和条件变量配合 **常见陷阱：** 1. **锁粒度问题** ```cpp // 错误：锁范围过大 std::lock_guard<std::mutex> guard(mtx); for(int i=0; i<10000; ++i) { // 非临界区操作也被锁住 } ``` - 💡 优化：最小化临界区范围[^4] 2. **死锁场景** ```cpp // 双锁死锁示例 std::mutex mtx1, mtx2; void thread1() { mtx1.lock(); mtx2.lock(); // 若thread2先锁mtx2... } void thread2() { mtx2.lock(); mtx1.lock(); // 死锁发生 } ``` - ✅ 解决方案：使用`std::lock()`原子锁定多个互斥量 ```cpp std::lock(mtx1, mtx2); // 原子获取双锁 std::lock_guard<std::mutex> lk1(mtx1, std::adopt_lock); std::lock_guard<std::mutex> lk2(mtx2, std::adopt_lock); ``` --- #### 二、条件变量(std::condition_variable) 条件变量解决"忙等待"问题，允许线程在特定条件满足时被唤醒。 **生产者-消费者模式：** ```cpp #include <queue> #include <condition_variable> std::mutex mtx; std::condition_variable cv; std::queue<int> data_queue; // 生产者 void producer() { while(true) { std::unique_lock<std::mutex> lock(mtx); data_queue.push(42); lock.unlock(); cv.notify_one(); // 通知消费者 } } // 消费者 void consumer() { while(true) { std::unique_lock<std::mutex> lock(mtx); // 处理虚假唤醒：必须使用循环判断 cv.wait(lock, []{ return !data_queue.empty(); }); int data = data_queue.front(); data_queue.pop(); lock.unlock(); // 处理数据... } } ``` **关键机制：** 1. **等待操作分解** ``` cv.wait(lock, predicate) 等价于： while (!predicate()) { cv.wait(lock); } ``` - 🛡️ **必要性**：防止虚假唤醒(spurious wakeup)[^5] 2. **通知机制** - `notify_one()`: 唤醒一个等待线程 - `notify_all()`: 唤醒所有等待线程 **典型应用场景：** 1. 线程池任务调度 2. 读写锁实现 3. 事件驱动系统 4. 有限状态机协调 --- ### ️ 核心注意事项 1. **互斥锁与条件变量必须配合使用** - 条件变量操作必须持有互斥锁，否则导致竞态条件[^2] 2. **等待前手动解锁的必要性** ```cpp // 优化性能 std::unique_lock<std::mutex> lock(mtx); cv.wait(lock, predicate); // 等价于： // lock.unlock(); // 进入等待... // lock.lock(); ``` 3. **条件变量生命周期管理** - 条件变量必须先于等待线程销毁 - 析构时需确保无线程等待，否则UB[^5] --- ### 🌟 最佳实践 1. **优先选用RAII包装器** - 使用`lock_guard`替代手动`lock()/unlock()`[^4] 2. **条件检查范式** ```cpp cv.wait(lock, [&]{ return !queue.empty(); }); ``` - ✅ 明确条件表达式 - ❌ 避免仅靠标志变量 3. **性能敏感场景优化** ```cpp // 减少锁竞争 void consume_batch() { std::vector<int> batch; { std::unique_lock<std::mutex> lock(mtx); cv.wait(lock, [&]{ return queue.size()>=10; }); for(int i=0; i<10; ++i) { batch.push_back(queue.front()); queue.pop(); } } // 批量处理（无锁状态） } ``` > 工业统计：合理使用条件变量可将线程等待能耗降低70%，避免忙等待的CPU空转[^3]。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值