基于std::map实现的线程安全的map以及测试

最新推荐文章于 2024-08-08 10:02:07 发布
最新推荐文章于 2024-08-08 10:02:07 发布
阅读量2.3k 收藏
点赞数 1
分类专栏： C++

// boostTest.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <string>
#include <iostream>
#include <sstream>
#include <map>
#include <Windows.h>
#define MyMap_CLock_Mutex_t                 HANDLE
#define MyMap_CLock_Mutex_Init(_mutex)      (_mutex = CreateSemaphore(NULL,1,1,NULL))
#define MyMap_CLock_Mutex_Lock(_mutex)      (WaitForSingleObject(_mutex, INFINITE))
#define MyMap_CLock_Mutex_UnLock(_mutex)    (ReleaseSemaphore(_mutex,1,NULL))
#define MyMap_CLock_Mutex_Destroy(_mutex)   (CloseHandle(_mutex))
#define MyMap_Declar_Typename               typename
#define MyMap_Type_Typename

using namespace std;

//************************************  
// 函数名称: PthreadSelf
// 函数说明： 获取线程ID内联函数
// 作 成 者：smallErLang  
// 作成日期：2016/04/22
// 返 回 值: unsigned int ：返回当前线程的ID
//************************************
inline unsigned int PthreadSelf()
{
    return GetCurrentThreadId();
}

namespace mymap
{
    template<class K, class V>
    class map;

    template<class K, class V>
    class myiterator;

    //lock
    class CLock  
    {  
    public:
        CLock(){MyMap_CLock_Mutex_Init(_mutex);}
        ~CLock(){MyMap_CLock_Mutex_Destroy(_mutex);}

        void Lock() {MyMap_CLock_Mutex_Lock(_mutex);}
        void UnLock() {MyMap_CLock_Mutex_UnLock(_mutex);}


    private:
        MyMap_CLock_Mutex_t _mutex;
    };

    //threadlockstats
    /************************************************************************/
    /*
        1.CThreadLockStats是保存了当前所有线程调用_mutex_usr.Lock()和_mutex_usr.UnLock()
        的差值,记录同一线程中_mutex_usr的使用情况。
        2.类中可用函数为TryLock(),TryUnLock()，如果同一线程中_mutex_usr已经Lock，则TryLock()
        不再锁，只是将标识自增；如果同一线程中_mutex_usr的Lock次数为1同时需要释放锁的时候，
        调用TryUnLock会释放，不为1则将标识自减。
    */
    /************************************************************************/
    template<class K, class V>
    class CThreadLockStats
    {
    private:
        CThreadLockStats();
        ~CThreadLockStats();

        //************************************  
        // 函数名称: TryLock
        // 函数说明： 防止重锁
        // 作 成 者：smallErLang  
        // 作成日期：2016/04/22
        // 返 回 值: void  
        //************************************
        void TryLock();

        //************************************  
        // 函数名称: TryUnLock
        // 函数说明： 与TryLock对应的释放锁
        // 作 成 者：smallErLang  
        // 作成日期：2016/04/22
        // 返 回 值: void  
        //************************************
        void TryUnLock();

    private:
        CLock _mutex_usr;

        CLock _mutex_stats;

        std::map<unsigned int, int>* _thread_lock_stats;

        friend mymap::map<K, V>;

        friend mymap::myiterator<K, V>;
    };

    template<class K, class V>
    void mymap::CThreadLockStats<K, V>::TryUnLock()
    {
        bool _isneedusrunlock = false;
        unsigned int _thread_id = PthreadSelf();

        _mutex_stats.Lock();

        if(_thread_lock_stats){
            MyMap_Type_Typename std::map<unsigned int, int>::iterator _finditr = _thread_lock_stats->find(_thread_id);

            if(_finditr != _thread_lock_stats->end()){

                if(_finditr->second == 1){

                    _isneedusrunlock = true;
                }

                _finditr->second -= 1;

            }else{

                int _new_lock_counts = 0;

                _thread_lock_stats->insert(MyMap_Type_Typename std::map<unsigned int, int>::value_type(_thread_id, _new_lock_counts));
            }
        }

        _mutex_stats.UnLock();

        if(_isneedusrunlock){

            _mutex_usr.UnLock();
        }
    }

    template<class K, class V>
    void mymap::CThreadLockStats<K, V>::TryLock()
    {
        bool _isneedusrlock = false;
        unsigned int _thread_id = PthreadSelf();

        _mutex_stats.Lock();

        if(_thread_lock_stats){

            MyMap_Type_Typename std::map<unsigned int, int>::iterator _finditr = _thread_lock_stats->find(_thread_id);

            if(_finditr != _thread_lock_stats->end()){

                if(_finditr->second <= 0){

                    _finditr->second = 0;

                    _isneedusrlock = true;
                }

                _finditr->second += 1;
            }else{

                int _new_lock_counts = 1;

                _thread_lock_stats->insert(MyMap_Type_Typename std::map<unsigned int, int>::value_type(_thread_id, _new_lock_counts));

                _isneedusrlock = true;
            }
        }

        _mutex_stats.UnLock();

        //将_mutex_usr.Lock放置于_mutex_stats释放后，防止死锁
        //函数中非成对出现的锁加上其他锁在多线程调用时一定会出现死锁
        if(_isneedusrlock){

            _mutex_usr.Lock();
        }
    }

    template<class K, class V>
    mymap::CThreadLockStats<K, V>::~CThreadLockStats()
    {
        _mutex_stats.Lock();

        delete _thread_lock_stats;

        _thread_lock_stats = NULL;

        _mutex_stats.UnLock();
    }

    template<class K, class V>
    mymap::CThreadLockStats<K, V>::CThreadLockStats()
    {
        _thread_lock_stats = new std::map<unsigned int, int>;
    }

    //myiterator:迭代器继承标准迭代器,减少运算符和一些函数的重载
    template<class K, class V>
    class myiterator: public MyMap_Type_Typename std::map<K, V>::iterator
    {
    public:
        myiterator();
        //************************************  
        // 函数名称: myiterator
        // 函数说明： 重载拷贝构造，方便拷贝时就Lock,释放时就UnLock；
        // 作 成 者：smallErLang  
        // 作成日期：2016/04/22
        // 返 回 值:   
        // 参    数: const myiterator & val_
        //************************************
        myiterator(const myiterator& val_);
        ~myiterator();

        //************************************  
        // 函数名称: operator=
        // 函数说明： 赋值运算会隐藏父类赋值函数，不会继承，需要重载
        // 作 成 者：smallErLang  
        // 作成日期：2016/04/22
        // 返 回 值: myiterator&  
        // 参    数: const myiterator & val_
        //************************************
        myiterator& operator=(const myiterator& val_);

    private:
        myiterator& operator=(const MyMap_Declar_Typename std::map<K, V>::iterator& val_);

    private:
        CThreadLockStats<K, V>* _mutex_stats;

        friend mymap::map<K, V>;
    };

    template<class K, class V>
    mymap::myiterator<K, V>& mymap::myiterator<K, V>::operator=( const mymap::myiterator<K, V>& val_ )
    {
        _mutex_stats = val_._mutex_stats;

        if(_mutex_stats){

            _mutex_stats->TryLock();
        }

        this->std::map<K, V>::iterator::operator=(val_);

        return *this;
    }

    template<class K, class V>
    mymap::myiterator<K, V>::myiterator( const myiterator& val_ )
    {
        _mutex_stats = val_._mutex_stats;

        if(_mutex_stats){

            _mutex_stats->TryLock();
        }

        this->std::map<K, V>::iterator::operator=(val_);
    }

    template<class K, class V>
    mymap::myiterator<K, V>& mymap::myiterator<K, V>::operator=( const MyMap_Declar_Typename std::map<K, V>::iterator& val_ )
    {
        this->std::map<K, V>::iterator::operator=(val_);

        return *this;
    }

    //************************************  
    // 函数名称: ~myiterator
    // 函数说明： 迭代器赋值和拷贝构造时Lock，析构时需要释放锁
    // 作 成 者：smallErLang  
    // 作成日期：2016/04/22
    // 返 回 值:   
    //************************************
    template<class K, class V>
    mymap::myiterator<K, V>::~myiterator()
    {
        if(_mutex_stats){

            _mutex_stats->TryUnLock();
        }

        _mutex_stats = NULL;
    }

    template<class K, class V>
    mymap::myiterator<K, V>::myiterator()
    {
        _mutex_stats = NULL;
    }

    //mymap
    /************************************************************************/
    /*
        由于iterator默认构造函数没有TryLock，所以在返回该类型临时变量时需要TryLock一次，
    临时变量析构时TryUnLock一次；将返回的值进行拷贝构造或者拷贝赋值会TryLock一次，使用
    完后析构TryUnLock一次。达到成对锁和释放锁的目的。
    */
    /************************************************************************/
    template<class K, class V>
    class map: private std::map<K, V>
    {
    public:
        map();
        map(const map& val_);
        ~map();

        map& operator=(const map& val_);

        typedef MyMap_Declar_Typename myiterator<K, V> iterator;

        void insert_s(const K& key_, const V& val_);
        void erase_s(const K& key_);
        void erase_s(iterator& itr_);
        iterator find_s(const K& key_);

        iterator begin_s();
        iterator end_s();

        unsigned int size_s();

    private:
        CThreadLockStats<K, V> _mutex_stats;
    };

    template<class K, class V>
    unsigned int mymap::map<K, V>::size_s()
    {
        unsigned int _size = 0;

        _mutex_stats.TryLock();

        _size = this->size();

        _mutex_stats.TryUnLock();

        return _size;
    }

    template<class K, class V>
    typename mymap::map<K, V>::iterator mymap::map<K, V>::end_s()
    {
        mymap::map<K, V>::iterator _ret;

        _ret._mutex_stats = &_mutex_stats;

        _mutex_stats.TryLock();

        _ret = this->end();

        return _ret;
    }

    template<class K, class V>
    typename mymap::map<K, V>::iterator mymap::map<K, V>::begin_s()
    {
        mymap::map<K, V>::iterator _ret;

        _ret._mutex_stats = &_mutex_stats;

        _mutex_stats.TryLock();

        _ret = this->begin();

        return _ret;
    }

    template<class K, class V>
    typename mymap::map<K, V>::iterator mymap::map<K, V>::find_s( const K& key_ )
    {
        mymap::map<K, V>::iterator _ret;

        _ret._mutex_stats = &_mutex_stats;

        _mutex_stats.TryLock();

        _ret = this->find(key_);

        return _ret;
    }

    template<class K, class V>
    void mymap::map<K, V>::erase_s( typename mymap::map<K, V>::iterator& itr_ )
    {
        _mutex_stats.TryLock();

        this->erase(itr_);

        _mutex_stats.TryUnLock();
    }

    template<class K, class V>
    void mymap::map<K, V>::erase_s( const K& key_ )
    {
        _mutex_stats.TryLock();

        this->erase(key_);

        _mutex_stats.TryUnLock();

        return ;
    }

    template<class K, class V>
    void mymap::map<K, V>::insert_s( const K& key_, const V& val_ )
    {
        _mutex_stats.TryLock();

        this->insert(std::map<K, V>::value_type(key_, val_));

        _mutex_stats.TryUnLock();

        return ;
    }

    template<class K, class V>
    mymap::map<K, V>& mymap::map<K, V>::operator=( const map& val_ )
    {
        val_._mutex_stats.TryLock();

        this->std::map<K, V>::operator =(val_);

        val_._mutex_stats.TryUnLock();

        return *this;
    }

    template<class K, class V>
    mymap::map<K, V>::~map()
    {

    }

    template<class K, class V>
    mymap::map<K, V>::map( const mymap::map<K, V>& val_ )
    {
        val_._mutex_stats.TryLock();

        this->std::map<K, V>::operator =(val_);

        val_._mutex_stats.TryUnLock();
    }

    template<class K, class V>
    mymap::map<K, V>::map()
    {

    }
}


int _tmain(int argc, _TCHAR* argv[])
{
    mymap::map<std::string, std::string> testMap;
    for (int i=0; i<100000; i++) {
        stringstream ss;
        stringstream ss2;
        ss<<i;
        ss2<<i;
        string k;
        string v;
        ss>>k;
        ss2>>v;
        k += "_key";
        v += "_value";
        testMap.insert_s(k, v);
    }
    cout << "testMap size:[" << testMap.size_s() << "]." << endl;

    /*
    mymap::map<std::string, std::string>::iterator iter;
    for (iter=testMap.begin_s(); iter!=testMap.end_s(); iter++) {
        cout << "Key=[" << iter->first << "], Value=[" << iter->second << "]." << endl;
    }
    */
    mymap::map<std::string, std::string>::iterator iter = testMap.find_s("88873_key");
    if (iter != testMap.end_s())
    {
        cout << "Key=[" << iter->first << "], Value=[" << iter->second << "]." << endl;
    }
    system("pause");
    return 0;
}

 

理查德大叔
关注
专栏目录
线程安全的std :: map和无锁映射的速度
04-11
综上所述，这个主题深入探讨了在C++多线程环境下如何实现线程安全的数据结构，特别是std::map，以及如何通过无锁编程和无争用共享互斥体来提高并发性能。通过分析和测试示例，我们可以了解这些技术的实际应用效果，...
C++ 实现线程安全的map
草上爬的博客
11-17 6919
STL容器不是线程安全的。比如对于vector，即使写方（生产者）是单线程写入，但是并发读的时候，由于潜在的内存重新申请和对象复制问题，会导致读方（消费者）的迭代器失效。实际表现也就是招致了core dump。另外一种情况，如果是多个写方，并发的push_back()，也会导致core dump。但可以通过固定vector的大小（调用resize()）避免动态扩容（无push_back）来做到lock-free。
基于C++标准map的多线程安全容器mymap::map进化版
chenjuan0926的博客
04-22 1021
#pragma once #include <map> #if defined _WIN32 //Windows #include <Windows.h&gt...
Java中线程安全的Map
最新发布
yuanmomoya的博客
08-08 1503
在Java中，是线程不安全的。在多线程环境中，我们需要其它线程安全的Map来进行操作。
关于C++ std::map的线程安全问题
weixin_43815862的博客
09-27 571
c++ stl map 线程安全
C++11:基于std::unordered_map和共享锁构建线程安全的map
热门推荐
10km的专栏
07-30 2万+
前一篇博客《C++:基于std::queue和std::mutex构建一个线程安全的队列》中，我们实现了一个线程安全的队列，本文我们说说如何实现一个线程安全的map。 在上一篇博客中，实现threadsafe_queue主要是依赖std::mutex信号量来实现线程对threadsafe_queue的独占访问,不论是只读的函数还是写函数对threadsafe_queue都是独占访问,因为对thre
C++ 多线程 线程安全关联性map设计
weixin_62953519的博客
11-19 1775
2：当一个线程结束访问哈希表是，进入exit函数，判断是否能哈希表是否能进行访问，如果不能，则说明哈希表正在等待扩张，这再判断此刻是否已经没有线程对哈希表进行访问，如果是的话，则唤醒哈希表，进行扩张；但是要注意，当我们的哈希表扩张时，要保证此刻哈希表没有线程进行访问，且要保证在进行扩展的这段时间，线程能够进行访问的，为此我利用了两个环境变量和两个原子对象来控制这个流程，下面简单描述一下逻辑；：效率底下，每次访问树都需要经过根节点，这说明我们要拿一个互斥量来保护根节点，这很不好，因为访问根节点的次数太多了；
C++利用map实现并查集
12-17
在C++中，我们可以利用`std::map`来实现并查集。`fathermap`是一个`, data>`类型的映射，用于存储每个元素的父结点。初始时，每个元素都是自己的父结点，即每个元素都是一个独立的集合。在`finddeputy`函数中，我们...
Map (c++实现的简易map)
03-16
在C++标准库中，`Map`被实现为`std::map`，但在这个场景中，我们讨论的是一个用户自定义的简易`Map`实现，名为"MyMap"，这是在Visual Studio 2013环境下编写的。 自定义`Map`的主要目的是为了学习和理解数据结构的...
me_std:个人标准库
03-16
5. **线程与并发**：C++11引入了多线程支持，"me_std"可能包含了一些线程安全的工具类，以及帮助管理和同步线程的函数，如锁、条件变量等。 6. **异常处理**：为了增强代码的健壮性，"me_std"可能提供了一些定制的...
Std:2курсик
03-16
Java内置了对多线程的支持，通过Thread类和Runnable接口，开发者可以创建并管理多个执行线程，实现并发编程。理解线程的生命周期，学会同步机制（如synchronized关键字，wait()、notify()方法）以避免数据竞争，是...
多线程map容器互斥代码
09-04
题目要求如下: //使用多线程，定时器和map等编程技巧。 // 定义map对象来存储数据，主线程中定时向该对象插入数据，每次插入两个连续的数据插入后显示出当前map大小。 //第二个线程定时删除map中的数据，每次删除一个最前面的数据，删除后显示当前的map大小。 //当主线程判断当前的map大小为1000时，终止第二个线程。确保第二个线程结束后主线程退出。 //在对map进行操作时，要加临界区保护。
safe-map:安全的
05-17
安全地图 作者：Karen Pease（ ） 许可证：公共领域。 尽你所能！ 没有明示或暗示的担保。 介绍 线程对许多现代应用程序至关重要，最新的C ++标准使启动线程和控制锁变得容易。 不幸的是，STL容器本身不是线程安全的。 尽管可以通过为容器保留一个互斥锁并为每个操作锁定它来解决单个容器函数调用的非原子性，但是不幸的是，这不能使迭代器安全到地图。 即使具有智能指针的映射也不会削减它-迭代器包含指向智能指针的指针，但不包含指向智能指针本身的指针，因此不会保留引用。 有几种方法可以解决此问题。 例如，英特尔的TBB包含多个“线程安全”容器。 不幸的是，您会发现它们对保留迭代器也不起作用-它们仅确保原子操作。 另一种选择是跳过使用迭代器，仅存储密钥。 但这意味着每次您要使用迭代器时都进行键查找-即使是简单的增量也是如此。 这可能很慢，尤其是在需要排序的情况下（映射与哈希）。 使用这种
C++线程安全map （低效率）
veghlreywg的博客
06-26 8349
map的并发操作是不安全的，C++里边有红黑树实现的std::map和hash表 unordered_map。 在《C++并发编程实战》一书中的162页提供了一个细粒度锁的MAP数据结构。 使用了boost的shared_mutex (C++14已经支持，C++11没有) 使用了std::hash 大家可以参考这本书的实现，如果支持C++14的话可以不用boost。 我这里简单写一个对std::map整个数据结构加锁的简单的类，我是在自己写一些测试demo的时候可能会用。 #ifnde...
精通高并发与多线程，却不会用ThreadLocal？
Cbuc丶的博客
11-08 471
大家好，我是小菜，一个渴望在互联网行业做到蔡不菜的小菜。可柔可刚，点赞则柔，白嫖则刚！ 死鬼~看完记得给我来个三连哦！ 本文主要介绍 ThreadLocal 的使用 如有需要，可以参考 如有帮助，不忘 点赞 ❥ 微信公众号已开启，小菜良记，没关注的同学们记得关注哦！ 之前我们有在并发系列中提到 ThreadLocal 类和基本使用方法，那我们就来看下 ThreadLocal 究竟是如何使用的！ ThreadLocal 简介 概念 ThreadLocal 类是用来提供线程内部的局部变量。这种变量在多线程
你的也是我的。3例ko多线程，局部变量透传
小姐姐味道
08-19 569
原创：小姐姐味道（微信公众号ID：xjjdog），欢迎分享，转载请保留出处。java中的threadlocal，是绑定在线程上的。你在一个线程中set的值，在另外一个线程...
string不是std的成员_C++基础：std::thread多线程
weixin_39963287的博客
11-23 768
std::thread>声明:*此系列为个人工作及学习所遇到问题的总结，相关参考的部分我都会以[参考**]()的形式标注出来。*C++11 线程支持库 std::thread定义于头文件 class thread; 类 thread 表示单个执行线程。线程允许多个函数同时执行。 线程在构造关联的线程对象时立即开始执行（等待任何OS调度延迟），从提供给作为构造函数参数的顶层函数开始。顶层函数...
C++ 实现线程安全的map(OpenHarmony源码实现版)
独行猫a 的沉淀、积累、总结。天天学习，好好向上...c/c++,嵌入式 linux,Android,HarmonyOS)
10-20 4507
c++的map的并发操作是不安全的，C++里边有红黑树实现的std::map和hash表 unordered_map。 在《C++并发编程实战》一书中的162页提供了一个细粒度锁的MAP数据结构，使用了 boost的shared_mutex (C++14已经支持，C++11没有)。这里给出个OpenHarmony源码实现的safe_map。
C++ 关于无锁map的一些思考（线程安全）
qq_38781075的博客
06-28 2312
1、map 的 key 是可以穷举的2、允许修改已经删除的 value，我们认为是创建了新 value 再修改。
std::unordered_map 是否线程安全？
02-02
3. 使用线程安全的容器：C++11 引入了一些线程安全的容器，如 std::unordered_map 的线程安全版本 std::unordered_map<std::shared_mutex>。这些容器在实现上使用了锁或其他机制来保证线程安全性。 需要注意的是，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值