基于C++标准map的多线程安全容器mymap::map进化版

最新推荐文章于 2024-05-02 09:34:45 发布
最新推荐文章于 2024-05-02 09:34:45 发布
阅读量993 收藏 3
点赞数
文章标签： c/c++
原文链接：https://my.oschina.net/u/2375158/blog/664454
版权 
#pragma once

#include <map>

#if defined  _WIN32                                                         //Windows
#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

#elif defined __linux                                                       //Linux
#include <pthread.h>
#define MyMap_CLock_Mutex_t                 pthread_mutex_t
#define MyMap_CLock_Mutex_Init(_mutex)      (pthread_mutex_init(&_mutex, NULL))
#define MyMap_CLock_Mutex_Lock(_mutex)      (pthread_mutex_lock(&_mutex))
#define MyMap_CLock_Mutex_UnLock(_mutex)    (pthread_mutex_unlock(&_mutex))
#define MyMap_CLock_Mutex_Destroy(_mutex)   (pthread_mutex_destroy(&_mutex))
#define MyMap_Declar_Typename 
#define MyMap_Type_Typename                 typename
#endif

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

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()
	{

	}
}

    WIN下是测试OK的，因时间有限，Linux下编译时需要自己调试下，但是编写的函数都是支持WIN和Linux的。

转载于:https://my.oschina.net/u/2375158/blog/664454

chenjuan0926
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++ 实现线程安全的map
草上爬的博客
11-17 6539
STL容器不是线程安全的。比如对于vector，即使写方（生产者）是单线程写入，但是并发读的时候，由于潜在的内存重新申请和对象复制问题，会导致读方（消费者）的迭代器失效。实际表现也就是招致了core dump。另外一种情况，如果是多个写方，并发的push_back()，也会导致core dump。但可以通过固定vector的大小（调用resize()）避免动态扩容（无push_back）来做到lock-free。
std map多线程_UNIX(多线程)：24哪些STL容器是线程安全的
weixin_42569329的博客
01-25 847
在日常C++开发，少不了和STL，多线程打交道，那么在多线程下，哪些容器时线程安全的，那些不是？ 好，这里就举一个简单的例子，我们先看看vector容器，相信你能看出一些问题：#include #include #include #include #include using namespace std;vector<int> vec;void...
线程安全map
shmily138的博客
07-18 207
#include “controller.h” #include #include #include <condition_variable> #include “ctrlindex.h” template<class Key, class T> class ThreadSaftMap { private: std::map<Key, T> m_map; mutable std::mutex m_mutex; std::condition_variable m_con
C++实现一个线程安全的map
最新发布
2301_79644036的博客
05-02 84
本文是使用ChatCPT生成的，最终的代码使用起来没问题。代码是通过两轮对话完善的，后面把对话合并后跑不出理想效果就没尝试了。
关于C++ std::map的线程安全问题
weixin_43815862的博客
09-27 417
c++ stl map 线程安全
线程安全的std :: map和无锁映射的速度
04-11
线程安全指针和无争用共享互斥体的使用和测试示例
MyMap：使用GoogleMap的示例
02-12
MyMap：使用GoogleMap的示例
MyMap:基于百度地图API和arcgisAPI的地图应用
05-10
MyMap基于百度地图API和arcgisAPI的地图应用
image-map-resizer：响应式HTML图像映射
02-07
您可以选择传递一个CSS选择器，该选择器返回地图标签的集合，例如“ map.myMap”。 或直接引用DOM中的地图对象。 此函数返回已绑定到的地图元素数组。 jQuery用法 包括和脚本，然后将以下调用添加到页面底部： $ ...
Demo分析学习《二》AirBike：类摩拜单车MAP地图使用
03-29
制作者：天下钞票 demo地址：AirBike：类摩拜单车MAP地图使用  很完整的demo，填写手机号码竟然真的可以收到验证码。今天试着分析了一下代码，将学习结果汇报一下：   亮点一、map组件的使用 ...map id="myMap
Map.prototype.toJSON:ES7 Map.prototype.toJSON polyfill
06-12
地图.prototype.tojson ES7 map.prototype.tojson polyfill安装 $ npm install --save map.prototype.tojson用法 require ( 'map.prototype.tojson' ) ;var myMap = new Map ( ) ;myMap . set ( NaN , "not a number...
c++ stl线程安全
08-07
c++ stl线程安全 c++ stl线程安全 c++ stl线程安全
多线程map容器互斥代码
09-04
题目要求如下: //使用多线程，定时器和map等编程技巧。 // 定义map对象来存储数据，主线程中定时向该对象插入数据，每次插入两个连续的数据插入后显示出当前map大小。 //第二个线程定时删除map中的数据，每次删除一个最前面的数据，删除后显示当前的map大小。 //当主线程判断当前的map大小为1000时，终止第二个线程。确保第二个线程结束后主线程退出。 //在对map进行操作时，要加临界区保护。
线程安全Map比较
liu_chenglong的博客
09-27 1330
线程安全Map比较 ConcurrentHashMap ConcurrentHashMap(以下简称CHM)是JUC包中的一个类，Spring的源码中有很多使用CHM的地方。之前已经翻译过一篇关于ConcurrentHashMap的博客，如何在java中使用ConcurrentHashMap，里面介绍了CHM在Java中的实现，CHM的一些重要特性和什么情况下应该使用CHM。需要注意的是，上面...
synchronized-CAS-ConcurrentHashMap -java内存模型-volatile
小净的博客
05-20 1213
1、线程池的底层工作原理 描述：系统是不可能说让他无限制的创建很多很多的线程的，会构建一个线程池，有一定数量的线程，让他们执行各种各样的任务，线程执行完任务之后，不要销毁掉自己，继续去等待执行下一个任务 fixed线程池（fixed，队列，LinkedBlockingQueue，无界阻塞队列）：ExecutorService threadPool = Executors.newFixedThreadPool(3) 提交任务，先看一下线程池里的线程数量是否小于corePoolSize（线程池中定义的数量）。如
C++多线程map读写加锁
tongshen的博客
12-24 9399
＃　C++多线程代码参考 定义线程函数 用map接受线程返回数据 void threadClsTask(int begin, int end, vector<Mat> imgList, BSMobileNet *bsMobileNet, map<int, int> *bsInfo){ int clsRes = bsMobileNet->inference(im...
STL的多线程安全问题
mercy_ps的博客
08-15 1422
多个线程可以同时读取一个容器中的内容，eg: find, begin, end 等. 多个线程对不同容器的同时写入合法。 但是，多个线程同时读写一个容器是很危险的。以map为例： 当你调用map的任何接口时，比如 end(), begin(), find()等时，可能会返回一个iterator，如果有别的线程正在修改这个map，你的iterator就变得无效了，再用这个iterator行为就...
Map 非线程安全的证明 以及线程安全方案（Concurrent）
司马懿的西山居
08-09 1822
参考 http://blog.csdn.net/nx188/article/details/50988037一、概述       大部分容器（比如：List、Map、Set）都是设计成非线程安全的，因为任何同步都是会损耗性能的。除了部分，如Vector是线程安全的。 线程安全的定义：       比如一个 ArrayList 类，在添加一个元素的时候，它可能会有两步来完成：1. 在 Items
C++ 多线程 线程安全关联性map设计
weixin_62953519的博客
11-19 1707
2：当一个线程结束访问哈希表是，进入exit函数，判断是否能哈希表是否能进行访问，如果不能，则说明哈希表正在等待扩张，这再判断此刻是否已经没有线程对哈希表进行访问，如果是的话，则唤醒哈希表，进行扩张；但是要注意，当我们的哈希表扩张时，要保证此刻哈希表没有线程进行访问，且要保证在进行扩展的这段时间，线程能够进行访问的，为此我利用了两个环境变量和两个原子对象来控制这个流程，下面简单描述一下逻辑；：效率底下，每次访问树都需要经过根节点，这说明我们要拿一个互斥量来保护根节点，这很不好，因为访问根节点的次数太多了；
std::map 多线程加锁问题
05-09
由于 `std::map` 是 STL 中的容器，它并不是线程安全的，因此在多线程环境下使用时需要注意加锁。在对 `std::map` 进行读写操作时，必须保证同一时间只有一个线程在进行操作，否则会出现数据竞争问题，导致程序崩溃...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值