C++ 线程锁 mutex 理解 附代码

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

#c++ #多线程 #并发编程

本文深入解析C++中的线程锁概念，包括mutex的基本原理、boost::mutex和std::mutex的使用，以及如何避免死锁。通过示例代码演示线程同步中锁的必要性和正确使用方法。

C++ 线程锁 mutex 理解 附代码

1. 概述

对C++里面的mutex相关知识进行梳理，理解线程锁。

2. 理解

mutex英文含义如下，表示一种不相容的性质。

mutex
n. 互斥；互斥元，互斥体；互斥量
  • C++里面的mutex类是用来进行线程同步，保护数据的，防止不同线程对同一数据同时进行处理。如果不使用线程锁会使程序不稳定，达不到预期的效果。
  • 它实际上是用来对线程进行处理的，不是直接处理数据。不同的线程只有拿到了线程锁才可以继续运行，否则需要等待其他线程解除线程锁。
  • 线程进行同步时需要进行线程锁的加锁、解锁的操作。如果加锁之后没有及时解锁可能会导致死锁现象。因为其他线程会等待其他线程解除线程锁，如果一直等不到，可能会一直处于阻塞的状态。

boost中的锁有

		class mutex
	    typedef mutex try_mutex;
    	class timed_mutex
        typedef unique_lock<mutex> scoped_lock;
        typedef detail::try_lock_wrapper<mutex> scoped_try_lock;
        typedef unique_lock<timed_mutex> scoped_timed_lock;
        typedef detail::try_lock_wrapper<timed_mutex> scoped_try_lock;
        typedef scoped_timed_lock scoped_lock;

3. boost::mutex

C++使用线程锁时最简单的就是使用boost::mutex。

3.1 无锁

如果不使用线程锁，代码示例如下
使用命令

 g++ nomutextest.cpp -o nomutex -lboost_system -lboost_thread

#include <boost/thread/thread.hpp> 
#include <iostream> 
#include <iomanip>

#include <unistd.h>

/* 
 * g++ nomutextest.cpp -o nomutex -lboost_system -lboost_thread
*/

int num = 5;
void helloA() 
{
   
    
        std::cout << "****I'm thread A ! " << boost::this_thread::get_id()  << " --- Start " << std::endl; 

        std::cout << "****I'm thread A the num is "<<num <<std::endl;

        num++;

        std::cout << "****I'm thread A the num+1 is "<<num <<std::endl;
        num++;

        std::cout << "****I'm thread A the num+1+1 is "<<num <<std::endl;

        sleep(1);

        std::cout << "****I'm thread A !  --- OVER " << std::endl; 

} 


  void helloB() 
{
   
    
        std::cout << "I'm thread B ! " << boost::this_thread::get_id()  << " --- Start " << std::endl; 

        std::cout << "I'm thread B the num is "<<num <<std::endl;

        num--;

        std::cout << "I'm thread B the num-1 is "<<num <<std::endl;
        num--;

        std::cout << "I'm thread B the num-1-1 is "<<num <<std::endl;


        std::cout << "I'm thread B !  --- OVER " << std::endl; 


} 

int main(int argc, char* argv[]) 
{
   
    
        // 建立并执行两个线程

        boost::thread thrdA(&helloA);


        boost::thread thrdB(&helloB);  


        thrdA.join(); // 等待子线程完成后再继续执行主进程;


        thrdB.join();


        // 等待两个 join 后才会继续执行
        std::cout<< " ==== over ==== "<<std::endl;

        return 0; 
}

由于线程实际运行时对num处理的先后顺序不一样导致结果不一样。
可能thrdA先对num进行加处理，可以允许
也有可能thrdB先对num进行减处理,可以允许
也有可能thrdA、thrdB对num同时进行处理。禁止这种情况
输出结果可能为下面情况

线程A先对num进行处理

A5 -> A6 -> A7->B7 -> B6 -> B5

****I'm thread A ! 7f01551c6700 --- Start I'm thread B ! 
****I'm thread A the num is 5
****I'm thread A the num+1 is 6
****I'm thread A the num+1+1 is 7
7f01549c5700 --- Start 
I'm thread B the num is 7
I'm thread B the num-1 is 6
I'm thread B the num-1-1 is 5
I'm thread B !  --- OVER 
****I'm thread A !  --- OVER 
 ==== over ====

或者

线程B先对num进行处理，

B5 -> B4 -> B3 -> A3 -> A4 -> A5

I'm thread B ! 7ff008235700 --- Start 
I'm thread B the num is 5
I'm thread B the num-1 is 4
I'm thread B the num-1-1 is 3
I'm thread B !  --- OVER 
****I'm thread A ! 7ff008a36700 --- Start 
****I'm thread A the num is 3
****I'm thread A the num+1 is 4
****I'm thread A the num+1+1 is 5
****I'm thread A !  --- OVER 
 ==== over ====

或者

线程A、B同时对num进行处理。

A5 -> A6 -> B6 -> B5 -> B4 -> A5

****I'm thread A ! I'm thread B ! 7f1c044567007f1c04c57700 --- Start  --- Start 
****I'm thread A the num is 5
****I'm thread A the num+1 is 
I'm thread B the num is 6
I'm thread B the num-1 is 5
6I'm thread B the num-1-1 is 4
I'm thread B !  --- OVER 

****I'm thread A the num+1+1 is 5
***
最低0.47元/天 解锁文章
【并发编程九】c++线程同步——互斥（mutex）
junxuezheng的博客
01-03 2078
简介：本篇文章，我们详细的介绍下c++标准库提供的线程同步方法中的第一个——互斥（mutex）。
【C++】互斥锁（Mutex）和原子操作（Atomics）
weixin_40514381的博客
03-27 1172
详细探讨 C++ 中的并发、多线程、互斥锁（Mutex）和原子操作（Atomics）的概念及其区别，并附带代码示例。
【C++】互斥锁（mutex）
Hi, Boy
05-04 1952
通过学习和掌握 C++ 中的互斥锁（mutex），可以更好地保护共享资源，确保多线程程序的正确性和稳定性。
c++ 11 多线线程系列----mutex
热门推荐
chen
11-11 2万+
Mutex 又称互斥量，C++ 11中与 Mutex 相关的类（包括锁类型）和函数都声明在 头文件中，所以如果你需要使用 std::mutex，就必须包含 头文件。 头文件介绍 Mutex 系列类(四种) std::mutex，最基本的 Mutex 类。std::recursive_mutex，递归 Mutex 类。std::time_mutex，定时 Mutex 类。st
C++ Mutex
weixin_44623642的博客
10-24 1488
互斥量可以使用在各种方面，常用在对共享数据的读写上。如果有多线程读写一个数据，那么想要保证线程安全，必须对共享变量的读写上锁递归式互斥锁，同一个线程可以多次获得锁，而不会死锁lock和unlock的次数必须相等，其他线程才能获得锁增加了带时限的try_lock以类似的方式，提供排他性递归锁，同线程可以重复获得锁。另外，通过与方法，提供带时限地获得锁，类似。c++ 17 新出的具有独占模式和共享模式的锁。
C++:mutex库
aixintianshideshouhu的博客
07-04 1万+
一、C++的mutex库 互斥量 C++11中提供了std::mutex互斥量，共包含四种类型： std::mutex：最基本的mutex类。 std::recursive_mutex：递归mutex类，能多次锁定而不死锁。 std::time_mutex：定时mutex类，可以锁定一定的时间。 std::recursive_timed_mutex：定时递归mutex类。 1、mutex 在多线程...
《探索C++多线程》：mutex源码（一）
hujingshuang
04-19 4918
互斥是为了防止多线程同时访问共享资源而产生的数据竞争，并提供多线程的同步支持。
C++ 多线程 互斥量（mutex）、锁（lock）和原子操作库
weixin_47755728的博客
06-17 1224
引自。
C++线程锁实现教程与源代码
C++提供了标准库中的<mutex>头文件来实现线程锁，其中包括了多种互斥量，如std::mutex、std::recursive_mutex、std::timed_mutex、std::recursive_timed_mutex以及对应的锁包装器如std::lock_guard、std::unique_...
C++ mutex
GET4_的博客
04-07 472
读写锁 shared_mutex 若一个线程已获取独占性锁（通常不直接调用 lock() ，用 std::unique_lock 与 std::lock_guard 管理排他性锁定 ），则无其他线程能获取该锁（包括共享的）。 仅当任何线程均未获取独占性锁时，共享锁能被多个线程获取（通过 std::shared_lock ）。 在一个线程内，同一时刻只能获取一个锁（共享或独占性）。 mutable std::shared_mutex mutex_; unsigned int value_ = 0; // 多
c++之mutex
大黄蜂的博客
12-19 3325
mutex前言头文件：操作lock, try_lock, unlocklocktry_lockunlocktry_lock_for, try_lock_untillock_guard, unique_lock，std::call_once, std::try_lock, std::lock(批量上锁)lock_guardunique_lockstd::call_oncestd::try_locks...
C++ mutex使用
zxcvb036的博客
02-07 302
//防止同一片内存被同时修改 #include <iostream> #include<thread> #include<vector> #include<algorithm> #include<functional> #include<mutex> using namespace std; struct A { int a; }; std::mutex _mutex; void func_add(A& a.
C++mutex的使用
sinat_31608641的博客
08-01 1万+
一、定义 C++11中提供了std::mutex互斥量，共包含四种类型： std::mutex：最基本的mutex类。 std::recursive_mutex：递归mutex类，能多次锁定而不死锁。 std::time_mutex：定时mutex类，可以锁定一定的时间。 std::recursive_timed_mutex：定时递归mutex类。 另外，还提供了两种锁类型： std::lock_guard：方便线程对互斥量上锁。 std::unique_lock：方便线程对互斥量上锁，但
【C++】互斥锁（Mutex）
最新发布
qq_40904479的博客
05-12 1469
在C++中，互斥锁（Mutex）是用于线程同步的重要工具，用于保护共享资源，防止多线程同时访问导致的数据竞争（Data Race）问题。合理选择互斥锁类型能有效提升代码的安全性和性能。自动管理锁，避免手动。
【C++】C++ 锁（std::mutex）的使用及其使用
原小明
04-26 3672
在C++中，锁是一种同步机制，用于保护共享资源在多线程环境下的访问安全，防止因并发访问导致的数据不一致、竞态条件等问题。
C++ 各种Mutex详解
bwabdbkjdbkjwabd的博客
02-13 6346
Mutex互斥锁 解释 mutex 类是能用于保护共享数据免受从多个线程同时访问的同步原语。mutex 提供排他性非递归所有权语义： 调用方线程从它成功调用 lock 或 try_lock 开始，到它调用 unlock 为止占有 mutex 。 线程占有 mutex 时，所有其他线程若试图要求 mutex 的所有权，则将阻塞（对于 lock 的调用）或收到 false 返回值（对于 try_lock ）. 调用方线程在调用 lock 或 try_lock 前必须不占有 mutex 。 若 mutex 在仍为
c++多线程 及mutex锁
change life
01-09 646
直接操作 mutex，即直接调用 mutex 的 lock / unlock 函数。 此例顺带使用了 boost::thread_group 来创建一组线程。 boost::mutex mutex; int count = 0; void Counter() { mutex.lock(); int i = ++count; std::cout << "count == " <<
C++线程锁之互斥锁（mutex）
qq_35973549的博客
04-29 1792
今天面试提到了C++线程锁，因此在这里整理下相关知识点，便于复习。 线程之间的锁主要有互斥锁、条件锁、自旋锁、读写锁、递归锁（一般锁功能越强大，性能越低）。 这篇博客主要整理下互斥锁的一点基本知识。 mutex又称互斥量，用于提供对共享变量的互斥访问。 头文件：#include<mutex> 与std::thread一样，mutex相关类不支持拷贝构造、赋值。同时mut...
c++ mutex
Ken的博客
08-07 310
在c++等高级编程语言中，锁也是用来提供“访问保护”的，Mutex，互斥量，就是互斥访问的量。只在多线程编程中起作用。从c++11开始，c++提供了std::mutex类型，对于多线程的加锁操作提供了很好的支持。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值