C++ 模版与线程安全锁的应用

最新推荐文章于 2025-02-14 14:40:24 发布
最新推荐文章于 2025-02-14 14:40:24 发布
阅读量1k 收藏
点赞数
分类专栏： linux 应用层开发积累 文章标签： 安全锁的封装
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/KuaiPengFei_/article/details/10201487
版权
本文介绍了一个通用的安全编程框架，该框架提供了一种基于锁的安全机制，适用于多种数据类型和STL容器，确保了多线程环境下的数据一致性与安全性。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

/*
 * =====================================================================================
 *
 *       Filename:  safe.h
 *
 *    Description:  MT safe
 *
 *
 *
 * =====================================================================================
 */

#include <sys/types.h>
#include <pthread.h>

#ifndef __VOLLIN_J_SAFE_H__
#define __VOLLIN_J_SAFE_H__

#define LOCK(Mutex) JLockHelper __lock__(Mutex)

class JLockHelper;

struct JAbsXMutex
{
    virtual void Lock() const= 0;
    virtual void Unlock() const= 0;
};

/*****************************************************
 *  JXMutex    X锁（互斥锁）类
 *****************************************************/
class  JXMutex:public JAbsXMutex
{
public:
    JXMutex()
    {
        pthread_mutex_init (&m_Mutex,NULL);
    }
    virtual ~JXMutex()
    {
        pthread_mutex_destroy(&m_Mutex);
    }
private:
    JXMutex(const JXMutex&);                        //禁止锁拷贝
    const JXMutex& operator =(const JXMutex &);     //禁止锁赋值
public:
    void Lock() const
    {
        pthread_mutex_lock (&m_Mutex);    //锁定
    }
    void Unlock() const
    {
        pthread_mutex_unlock (&m_Mutex);    //解锁
    }
public:
    mutable pthread_mutex_t     m_Mutex;                    //互斥锁
};


/**************************************************************************************
 *  JSafe    基于各类锁的安全类模板
 **************************************************************************************/
template<class _Tp,class _Mutex = JXMutex>
class JSafe
{
public:
    typedef _Tp value_type;
    typedef _Mutex lock_type;
    JSafe(void){}
    ~JSafe(void){}
    explicit JSafe(const _Tp& other)
    {
        m_Data = other;
    }
    JSafe(const JSafe& other)
    {
        LOCK(other);
        m_Data = other.m_Data;
    }
    operator const _Tp() const   //定义强制类型转换，注意已锁定时不能使用;虽然使用起来方便，但实际上都可以由获取值的Value函数代替
    {
        LOCK(m_Mutex);
        return m_Data;
    }
    JSafe& operator =(const JSafe& other)
    {
        LOCK(other);
        {
            LOCK(m_Mutex);
            m_Data = other.m_Data;
        }
        return *this;
    }
    void Value(const _Tp& other)//设置值
    {
        LOCK(m_Mutex);
        m_Data = other;
    }
    const _Tp Value(void) const //获取值
    {
        LOCK(m_Mutex);
        return m_Data;
    }
    void Lock(void) const //加锁
    {
        m_Mutex.Lock();
    }
    void Unlock(void) const //解锁
    {
        m_Mutex.Unlock();
    }
    _Tp&    Data(void) //加锁后方可安全使用此函数得到资源的引用，如未加锁直接调用可能造成相应的安全问题
    {
        return m_Data;
    }
protected:
    _Tp m_Data;         //数据成员
    mutable _Mutex  m_Mutex;    //锁成员
    friend class JLockHelper;
};

/**************************************************************************************
 * JLockHelper    使用于有Lock,及Unlock成员函数的安全类或锁类的辅助加锁对象，
 *                可以做到异常安全的解锁
 * 说明:          在创建类时加锁,析构时解锁;一种简单的但不是必须的使用方法是使用{}
 *                将要加锁的代码括起来，在{}中第一行定义该辅助类，则}时将自动解锁
 ****************************************************************************************/
class JLockHelper
{
public:
    JLockHelper(const JAbsXMutex& xMutex):m_xMutex(xMutex)
    {
        m_xMutex.Lock();
    }

    template<class _Tp,class _Mutex>
    JLockHelper(const JSafe<_Tp,_Mutex>& S):m_xMutex(S.m_Mutex)
    {
        m_xMutex.Lock();
    }

    ~JLockHelper()
    {
        m_xMutex.Unlock();
    }

private:
    const JAbsXMutex& m_xMutex;
};


template<class _Tp>
class JSafeNum : public JSafe<_Tp>
{
public:
    typedef JSafe<_Tp> safe_type;
    explicit JSafeNum(const _Tp& _Value = 0):JSafe<_Tp>(_Value){}
    JSafeNum& operator ++()
    {
        LOCK(safe_type::m_Mutex);
        safe_type::m_Data++;
        return *this;
    }
    JSafeNum operator ++(int)
    {
        LOCK(safe_type::m_Mutex);
        JSafeNum tmp(safe_type::m_Data++);
        return tmp;
    }
    JSafeNum& operator +=(const _Tp& other)
    {
        LOCK(safe_type::m_Mutex);
        safe_type::m_Data += other;
        return *this;
    }
    JSafeNum& operator --(void)
    {
        LOCK(safe_type::m_Mutex);
        safe_type::m_Data--;
        return *this;
    }
    JSafeNum operator --(int)
    {
        LOCK(safe_type::m_Mutex);
        JSafeNum tmp(safe_type::m_Data--);
        return tmp;
    }
    JSafeNum& operator -=(const _Tp& other)
    {
        LOCK(safe_type::m_Mutex);
        safe_type::m_Data -= other;
        return *this;
    }
    JSafeNum& operator =(const _Tp& other)
    {
        LOCK(safe_type::m_Mutex);
        safe_type::m_Data = other;
        return *this;
    }
};

typedef JSafe<bool> JSafeBool;
typedef JSafeNum<int> JSafeInt;
typedef JSafeNum<long> JSafeLong;
typedef JSafeNum<u_int> JSafeUint;

//安全容器，适用于stl容器类
template<class _Con>
class JSafeCon :public JSafe<_Con>
{
public:
    typedef JSafe<_Con> _Base;
    typedef JSafeCon<_Con> _Self;
    typedef _Con con_type;
    typedef typename con_type::iterator iterator;
    explicit JSafeCon(void):_Base(){}
    bool empty()
    {
        LOCK(_Base::m_Mutex);
        return _Base::m_Data.empty();
    }
    size_t size()
    {
        LOCK(_Base::m_Mutex);
        return _Base::m_Data.size();
    }
    void swap(con_type& Seq)
    {
        LOCK(_Base::m_Mutex);
        _Base::m_Data.swap(Seq);
    }
    //以下两个函数及其使用均需在同步的保护下
    iterator begin()
    {
        return _Base::m_Data.begin();
    }
    iterator end()
    {
        return _Base::m_Data.end();
    }
};

//安全序列（适用于stl的序列容器类如vector,list,...)
template<class _Sequence>
class JSafeSeq : public JSafeCon<_Sequence>
{
public:
    typedef JSafeCon<_Sequence> _Base;
    typedef JSafeSeq<_Sequence> _Self;
    typedef _Sequence seq_type;
    typedef typename seq_type::iterator iterator;
    typedef typename seq_type::value_type value_type;

    explicit JSafeSeq(void):_Base(){}
    void push_back(const value_type& Val)
    {
        LOCK(_Base::m_Mutex);
        _Base::m_Data.push_back(Val);
    }
};

//适用于stl前向插入序列如deque等
template<class _FSeq>
class JSafeFSeq:public JSafeSeq<_FSeq>
{
public:
    typedef JSafeSeq<_FSeq> _Base;
    typedef JSafeFSeq<_FSeq> _Self;
    typedef typename _Base::seq_type seq_type;
    typedef typename seq_type::iterator iterator;
    typedef typename seq_type::value_type value_type;

    explicit JSafeFSeq(void):_Base(){}

    bool pop_front(value_type& Val)//取出第一个元素
    {
        LOCK(_Base::m_Mutex);
        if (_Base::m_Data.empty())
        {
            return false;
        }
        else
        {
            Val = *(_Base::m_Data.begin());
            _Base::m_Data.pop_front();
            return true;
        }
    }
};

//安全map类，适用于stl::map
template<class _Map>
class JSafeMap :public JSafeCon<_Map>
{
public:
    typedef JSafeCon<_Map> _Base;
    typedef JSafeSeq<_Map> _Self;
    typedef _Map map_type;
    typedef typename map_type::iterator iterator;
    typedef typename map_type::const_iterator const_iterator;
    typedef typename map_type::value_type value_type;
    typedef typename value_type::first_type key_type;
    typedef typename value_type::second_type data_type;
    explicit JSafeMap(void):_Base(){}
    void insert(const value_type& Val)
    {
        LOCK(_Base::m_Mutex);
        _Base::m_Data.insert(Val);
    }
    bool find(const key_type& Key) const
    {
        LOCK(_Base::m_Mutex);
        return _Base::m_Data.find(Key) != _Base::m_Data.end();
    }
    bool find(const key_type& Key,data_type& Val) const
    {
        LOCK(_Base::m_Mutex);
        const_iterator it = _Base::m_Data.find(Key);
        if ( _Base::m_Data.end() != it )
        {
            Val = it->second;
            return true;
        }
        return false;
    }
    void erase(const key_type& Key)
    {
        LOCK(_Base::m_Mutex);
        _Base::m_Data.erase(Key);
    }
    data_type get(const key_type& Key,const data_type& Default) const
    {
        LOCK(_Base::m_Mutex);
        const_iterator it = _Base::m_Data.find(Key);
        if ( _Base::m_Data.end() == it )
        {
            return Default;
        }
        else
        {
            return it->second();
        }
    }
    bool find_erase(const key_type& Key,data_type& Val)
    {
        LOCK(_Base::m_Mutex);
        iterator it = _Base::m_Data.find(Key);
        if ( _Base::m_Data.end() != it )
        {
            Val = it->second;
            _Base::m_Data.erase(it);
            return true;
        }
        return false;
    }
    void set(const key_type& Key,const data_type& Val)
    {
        LOCK(_Base::m_Mutex);
        _Base::m_Data[Key] = Val;
    }
};

#endif //head file

 

 

【C++11 之单例模式线程安全原理+案例】及旧版本互斥锁线程安全案例
一起学习进步！
06-29 1268
在C++11之前，通常我们会使用互斥锁（如pthread_mutex_t在POSIX线程中，或者在C++标准库中使用std::mutex，尽管std::mutex是C++11引入的，但这里我们可以假设我们有一个兼容的互斥锁实现）来保证单例模式的线程安全。请注意，在上面的代码中，我们使用了pthread_mutex_t作为互斥锁，并使用pthread_mutex_lock和pthread_mutex_unlock函数来加锁和解锁。在C++11及之后的版本中，它被广泛用于实现线程安全的单例。
C++ 进程与线程
qq_37464701的博客
03-22 1415
程序：就是磁盘上的可执行文件，并且只占用磁盘上的空间，是一个静态的概念。进程：被执行后的程序就叫做进程，不占用磁盘空间，需要消耗系统的内存，CPU资源，每个运行的进程都对应一个属于自己的虚拟地址空间。？？？后面有空去了解下？？？CPU时间片：CPU在某个时间点只能处理一个任务，但是操作系统都支持多任务的，那么在计算机CPU只有一个的情况下是怎么完成任务处理的？原理和古时候救济灾民的思路是一样的，每个人分一点，但是又不叫吃饱。
C++对象锁模版
一叶知秋
10-28 1065
实现原理： 1、利用临时对象做保护 template class TempObject { T* m_ptr; Lock& m_lock; public: TempObject (Lock& lock, T* ptr)  : m_ptr(ptr), m_lock(lock) { m_lock.lock(); } ~TempObject () { m_lock.unlock()
模版和多态策略化加锁模式
weixin_30419799的博客
07-31 115
模版和多态策略化加锁模式 关键词：策略化模式 模版策略化 多态策略化 策略化加锁模式 ACE BOOST C++ 设计模式 在ACE和BOOST的实现中都有大量的策略化加锁（Strategized Locking）的模式，这种模式能比较方便的让你的类兼容加锁和不加锁的两种情况。ACE大师Douglas C. Schmidt有一片专门的论文《Strategized Lock...
C++中的几种锁
weixin_41326319的博客
04-22 324
通过构造std::mutex的实例创建互斥元，调用成员函数lock()来锁定它，调用unlock()来解锁，不过一般不推荐这种做法。它们的主要区别在于unique_lock锁机制更加灵活，可以再需要的时候进行lock或者unlock调用，不非得是析构或者构造时。unique_lock类模板，都是RAII风格，它们是在定义时获得锁，在析构时释放锁。标准C++库提供了std::lock_guard和。头文件：#include <mutex>
C++ 多线程编程(二) 各种各样的锁
a1367666195的博客
04-24 4716
本篇文章主要对C++现有的锁进行介绍，由于锁的种类繁多，而且相关文章已经非常多了，本文不再细讲各种锁的技术细节，而是更注重于各种锁的由来，以及他们针对的问题，如此便能针对自己面临的问题，选择合适的锁。 今天是2023年4月21号，目前我使用的是C++20，因此在这篇文章，我们记录C++20中各类的锁。主要包括基本锁和RAII锁，基本锁包括互斥锁 (mutex)，定时互斥锁 (timed_mutex)，条件变量 (condition_variable)，读写锁 (shared_mutex)，
C++中的锁总结
weixin_53344209的博客
04-30 2179
在同一时刻，我们只需保证对某个内存地址的操作是原子性即可，但总线锁定把CPU和内存之间的通信锁住了，这使得锁定期间，其他处理器不能操作其他内存地址的数据，所以总线锁定的开销比较大，目前处理器在某些场合下使用缓存锁定代替总线锁定来进行优化。但是，也不是说原子操作或者自旋锁（自旋锁一定程度上就是原子锁，只不过有临界区）一定比互斥锁快，以为当并发竞争很大的时候，CAS会导致太多的失败尝试，CPU消耗，这时候就不如使用互斥锁了。自旋锁亦可以用原子操作实现啊CAS的作用，它就是实现乐观锁的啊，可以实现自旋锁吗？
构建C++线程安全队列：深入实现与代码实践
11-28
具体到代码实现，可以参考模板类`ThreadSafeQueue`，它使用`std::queue`作为内部数据结构，并通过互斥锁与条件变量实现线程安全机制。其中，`push`方法用于入队操作，`pop`方法用于出队操作，`empty`与`size`方法...
C++多线程编程——“锁”住混乱：多线程厕所大战解密
最新发布
T_killer_的博客
02-14 852
当代码世界陷入“多线程厕所大战”，谁来维护秩序？本文将以幽默的例子揭开多线程编程中锁机制的神秘面纱。从基础到高级，我们一探究竟，如何用锁来锁住混乱，确保数据安全。帮你成为厕所（代码）的真正英雄！
C++多线程编程实践：线程锁与信号量的应用
通常，互斥锁与临界区（一段需要保护的代码）一起使用，可以确保在临界区内同一时刻只有一个线程在执行。 3. std::list容器 std::list是C++标准模板库（STL）中的一个容器，它是一个双向链表的数据结构。std::list...
c++多线程之模版类lock_guard和unique_lock
横扫天下的博客
05-23 411
c++多线程之模版类lock_guard和unique_lock简介lock_guardunique_lock 简介 之前讲解互斥锁mutex中提到，mutex的上锁lock()和解锁unlock()操作必须成对使用，一旦我们在一个线程中获取一个mutex锁后忘记在线程结束时解锁，那么这个锁将一值处于上锁状态，导致其他需要获取这个锁的线程一直处于阻塞状态从而饿死。为了避免大家犯这种低级错误，也为了更好更灵活的使用互斥锁，c++退出了模板类lock_guard和unique_lock。下面给大家具体讲解一下。
C++的模板(十)：shared_ptr的上锁问题
aaasssdddd96的博客
07-04 924
这个_M_ptr也是那个被引用计数管理的对象指针，在_Sp_counted_base及其派生类的管理范围内，如果引用计数归0，最后要销毁这个被管理的对象。执行完立即产生一个调度断点，那么别的线程可以在这个点上调度运行，如果凑巧也执行了一个 __shared_ptr ::swap()，并且是前面做到一半的那个__shared_ptr，那么它的执行导致_M_refcount被换走。加锁的办法，如果管理的是少量的大粒度的对象，可以使用单一的全局锁，如果管理的是大量的细粒度的对象，就要使用局部锁，对象粒度的锁。
STL容器 多线程安全问题 MT-safe or unsafe
ChengChengCheng的博客
02-14 339
https://www.cnblogs.com/juncheng/articles/1600728.html
C++多线程中互斥量std::mutex与模板类std::lock_guard
ctrigger的专栏
04-05 1340
一、 互斥量std::mutex C++中通过实例化std::mutex创建互斥量实例，通过成员函数lock()对互斥量上锁，unlock()进行解锁。C++中与std::mutex相关的类（包括锁类型）和函数都声明在< mutex >头文件中，要使用std::mutex，就必须包含此头文件。 #include <mutex> #include <thread&g...
C++11 14 17 20 多线程从原理到线程池实战
02-17
学习计划 每天学习一小时以上 跟着视频动手编写代码 调试代码并对比课程多提供的源码 课程目标 理解多线程原理并学会c++11 的多线程编程 理解线程池技术原理并能使用c++实现 理解c++11 14 17 20 多线程编程相关特性 常见问题 课程使用的开发工具？ 课程使用的开发工具是vs2019 课程代码是否是跨平台？ 课程代码都是基于c++自生特性，没有用到第三方库，都是跨平台 旧版本的开发工具是否可以？ 课程中的大部分代码是c++11 ，绝大部分开发工具都支持，其中c++14 17要比较新的工具支持，c++20需要vs2019 课程是否提供源码？ 课程提供源码，方便同学学习过程的出现问题，进行对照调试错误。   
c++线程中的几种锁
热门推荐
bian_qing_quan11的博客
06-26 5万+
这个是在中兴面试中被面试问到的一个题“你知道线程中的自旋锁么？”，我当时一脸懵逼，不知道。回来后整理下，在这里对线程中的锁进行一个学习。 线程之间的锁有：互斥锁、条件锁、自旋锁、读写锁、递归锁。一般而言，锁的功能越强大，性能就会越低。 1、互斥锁 互斥锁用于控制多个线程对他们之间共享资源互斥访问的一个信号量。也就是说是为了避免多个线程在某一时刻同时操作一个共享资源。例如线程池中的有多个线程和
C++安全锁的编写
11-18 643
下面介绍一种C++安全锁的写法： class CSection {    friend class CCSGuard; public:    CSection()     {        InitializeCriticalSection(&m_cs);     }      ~CSection()     {        DeleteCriticalSection(&
对C++锁的一些思考
Coder-Coder
03-05 3655
C++中的多线程编程是一个相对复杂，坑比较多，并且出现问题较难排查的一个编程领域，也是c++编写大型项目中避不开的部分。加锁的方式有很多，应用场景也各都稍有不同，根据不同维度（或者侧重点，比如是原子化操作还是通知，技术属于乐观锁还是悲观锁，内核级别还是用户级别，linux平台还是win平台）可以分成很多类别，但其作用都是服务于多线程程序的稳定运行，所以一般都统称为“锁”。比如原子类型（使用场景如在...
多线程的那点儿事（之C++锁）
java开发指南博客 【转载】
11-27 272
【 声明：版权所有，欢迎转载，请勿用于商业用途。 联系信箱：feixiaoxing @163.com】 编写程序不容易，编写多线程的程序更不容易。相信编写过多线程的程序都应该有这样的一个痛苦过程，什么样的情况呢？朋友们应该看一下代码就明白了， void data_process() { EnterCriticalSection(); if(/* error ha...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值