工具类库系列(十三)-ObjectSharedPtrMap2

最新推荐文章于 2024-09-15 23:39:19 发布

原创最新推荐文章于 2024-09-15 23:39:19 发布 · 401 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#map #读写锁 #线程安全 #迭代不失效

工具类库专栏收录该内容

16 篇文章

订阅专栏

介绍了一个线程安全的对象智能指针管理类ObjectSharedPtrMap2，它支持多线程环境下对象的添加、查找、删除等操作，并确保迭代过程中不会失效。通过维护迭代器列表，使得多个线程可以安全地进行迭代。

第十三个工具类：ObjectSharedPtrMap2

这是继ObjectMap之后，第三个Object对象管理类，管理的是对象的智能指针对象

功能与上一个ObjectSharedPtrMap类似

1、线程安全。

2、多线程环境下：有多个线程在迭代，其他线程在删除时，迭代不失效

3、多线程环境下：有多个线程在迭代，多个迭代互不干扰

如何支持多个线程的迭代，以及保证多个线程的迭代不失效：

用户可以用线程id，主调函数地址，其他能保证唯一的id或枚举，来区分不同的迭代

ObjectSharedPtrMap2中保存了每一个迭代当前的迭代器std::map::iterator对象的列表

当做删除操作时，先检查下要删除的这个对象是否是迭代器列表中的某个当前正在遍历的对象

是的话，则保存的迭代器后移，所有迭代器全部检查完再删除

提供的主要接口：

1、增加一个Object的SharedPtr对象：void AddObject(K id, boost::shared_ptr<T> obj);

2、查找一个Object对象，返回该对象的SharedPtr对象（没找到返回SharedPtr(NULL)）：boost::shared_ptr<T> FindObject(K id);

3、判断一个Object对象是否存在：bool IsExistsObject(K id);

4、删除一个Object对象：void FreeObject(K id);

5、删除所有（清空）Object对象：void FreeObject();

6、取出并删除一个Object对象：boost::shared_ptr<T> PopObject(K id);

7、获取Object对象的数量：unsigned int GetSize();

8、迭代：boost::shared_ptr<T> BeginObject(objectid64 iteratorId); boost::shared_ptr<T> NextObject(objectid64 iteratorId);

上代码：

ObjectSharedPtrMap2.h：

#ifndef __ObjectSharedPtrMap2_h__
#define __ObjectSharedPtrMap2_h__

#include <boost/noncopyable.hpp>
#include <boost/shared_ptr.hpp>
#include <map>

#include "ToolDefine.h"

namespace common{
	namespace tool{

		// 带键值对的对象管理池
		// 用于保证多线程环境下：
		//		有多个线程在迭代，其他线程在删除时，每一个迭代均不失效
		//		有多个线程在迭代，迭代相互间不干扰
		template <class K, class T>
		class ObjectSharedPtrMap2 : private boost::noncopyable
		{
		public:
			ObjectSharedPtrMap2();
			~ObjectSharedPtrMap2();

			// 使用一个空闲结点
			void AddObject(K id, boost::shared_ptr<T> obj);

			// 随机一个结点（分配第一个结点，空列表返回空）
			boost::shared_ptr<T> RandObject();

			// 随机取出一个结点（该节点从map删除）
			boost::shared_ptr<T> PopObject();
			// 取指定结点（该节点从map删除）
			boost::shared_ptr<T> PopObject(K id);

			// 查找一个结点
			boost::shared_ptr<T> FindObject(K id);
			bool IsExistsObject(K id);

			// 释放一个结点
			void FreeObject(K id);
			void FreeObject();

			// 获取对象个数
			unsigned int GetSize();

			// 迭代
			boost::shared_ptr<T> BeginObject(objectid64 iteratorId);
			boost::shared_ptr<T> BeginObject(objectid64 iteratorId, K id);
			boost::shared_ptr<T> NextObject(objectid64 iteratorId);
			void EndObject(objectid64 iteratorId);

		private:
			rw_mutex m_object_list_lock;

			typedef typename std::map<K, boost::shared_ptr<T> > MapType;
			typedef typename std::map<K, boost::shared_ptr<T> >::iterator MapTypeIterator;

			MapType m_object_list;

			typedef typename std::map<objectid64, MapTypeIterator> IteratorType;
			typedef typename std::map<objectid64, MapTypeIterator>::iterator IteratorTypeIterator;

			IteratorType m_it_list;
		};

		template <class K, class T>
		ObjectSharedPtrMap2<K, T>::ObjectSharedPtrMap2()
		{
			write_lock lock(m_object_list_lock);

			m_object_list.clear();
			m_it_list.clear();
		}

		template <class K, class T>
		ObjectSharedPtrMap2<K, T>::~ObjectSharedPtrMap2()
		{
			write_lock lock(m_object_list_lock);

			MapTypeIterator objIt = m_object_list.begin();
			while (objIt != m_object_list.end())
			{
				(objIt->second).reset();
				objIt++;
			}

			m_object_list.clear();
			m_it_list.clear();
		}

		template <class K, class T>
		void ObjectSharedPtrMap2<K, T>::AddObject(K id, boost::shared_ptr<T> obj)
		{
			if (NULL != obj.get())
			{
				write_lock lock(m_object_list_lock);

				// id已存在的需要提前删除
				MapTypeIterator objIt = m_object_list.find(id);
				if (objIt != m_object_list.end())
				{
					// 释放实际数据对象的引用
					(objIt->second).reset();

					// 后移相关迭代器
					IteratorTypeIterator itIt = m_it_list.begin();
					while (itIt != m_it_list.end())
					{
						MapTypeIterator& objTempIt = itIt->second;
						if (objTempIt == objIt)
						{
							objTempIt++;
						}

						itIt++;
					}

					// 删除结点
					m_object_list.erase(objIt);
				}

				// 添加新对象
				m_object_list[id] = obj;
			}
		}

		template <class K, class T>
		boost::shared_ptr<T> ObjectSharedPtrMap2<K, T>::RandObject()
		{
			read_lock lock(m_object_list_lock);

			MapTypeIterator objIt = m_object_list.begin();
			if (objIt != m_object_list.end())
			{
				return objIt->second;
			}
			else
			{
				boost::shared_ptr<T> temp((T*)NULL);
				return temp;
			}
		}

		template <class K, class T>
		boost::shared_ptr<T> ObjectSharedPtrMap2<K, T>::PopObject()
		{
			write_lock lock(m_object_list_lock);

			MapTypeIterator objIt = m_object_list.begin();
			if (objIt != m_object_list.end())
			{
				// 保存pop的ptr对象
				boost::shared_ptr<T> temp = objIt->second;

				// 后移相关迭代器
				IteratorTypeIterator itIt = m_it_list.begin();
				while (itIt != m_it_list.end())
				{
					MapTypeIterator& objTempIt = itIt->second;
					if (objTempIt == objIt)
					{
						objTempIt++;
					}

					itIt++;
				}

				// 删除结点
				m_object_list.erase(objIt);

				return temp;
			}
			else
			{
				boost::shared_ptr<T> temp((T*)NULL);
				return temp;
			}
		}

		template <class K, class T>
		boost::shared_ptr<T> ObjectSharedPtrMap2<K, T>::PopObject(K id)
		{
			write_lock lock(m_object_list_lock);

			MapTypeIterator objIt = m_object_list.find(id);
			if (objIt != m_object_list.end())
			{
				boost::shared_ptr<T> temp = objIt->second;

				// 后移相关迭代器
				IteratorTypeIterator itIt = m_it_list.begin();
				while (itIt != m_it_list.end())
				{
					MapTypeIterator& objTempIt = itIt->second;
					if (objTempIt == objIt)
					{
						objTempIt++;
					}

					itIt++;
				}

				// 删除结点
				m_object_list.erase(objIt);

				return temp;
			}
			else
			{
				boost::shared_ptr<T> temp((T*)NULL);
				return temp;
			}
		}

		template <class K, class T>
		boost::shared_ptr<T> ObjectSharedPtrMap2<K, T>::FindObject(K id)
		{
			read_lock lock(m_object_list_lock);

			MapTypeIterator objIt = m_object_list.find(id);
			if (objIt != m_object_list.end())
			{
				return objIt->second;
			}
			else
			{
				boost::shared_ptr<T> temp;
				return temp;
			}
		}

		template <class K, class T>
		bool ObjectSharedPtrMap2<K, T>::IsExistsObject(K id)
		{
			read_lock lock(m_object_list_lock);

			MapTypeIterator objIt = m_object_list.find(id);
			if (objIt != m_object_list.end())
			{
				return true;
			}
			else
			{
				return false;
			}
		}

		template <class K, class T>
		void ObjectSharedPtrMap2<K, T>::FreeObject(K id)
		{
			write_lock lock(m_object_list_lock);

			MapTypeIterator objIt = m_object_list.find(id);
			if (objIt != m_object_list.end())
			{
				// 释放实际数据对象的引用
				(objIt->second).reset();

				// 后移相关迭代器
				IteratorTypeIterator itIt = m_it_list.begin();
				while (itIt != m_it_list.end())
				{
					MapTypeIterator& objTempIt = itIt->second;
					if (objTempIt == objIt)
					{
						objTempIt++;
					}

					itIt++;
				}

				// 删除结点
				m_object_list.erase(objIt);
			}
		}

		template <class K, class T>
		void ObjectSharedPtrMap2<K, T>::FreeObject()
		{
			write_lock lock(m_object_list_lock);

			MapTypeIterator objIt = m_object_list.begin();
			while (objIt != m_object_list.end())
			{
				(objIt->second).reset();
				objIt++;
			}

			m_object_list.clear();
			m_it_list.clear();
		}

		template <class K, class T>
		unsigned int ObjectSharedPtrMap2<K, T>::GetSize()
		{
			read_lock lock(m_object_list_lock);

			return m_object_list.size();
		}

		template <class K, class T>
		boost::shared_ptr<T> ObjectSharedPtrMap2<K, T>::BeginObject(objectid64 iteratorId)
		{
			{
				write_lock lock(m_object_list_lock);

				// 新加该id对应的迭代器
				m_it_list[iteratorId] = m_object_list.begin();

				// 根据id，查找对应迭代器iterator
				IteratorTypeIterator itIt = m_it_list.find(iteratorId);
				if (itIt != m_it_list.end())
				{
					// 得到T的迭代器
					MapTypeIterator& objIt = itIt->second;
					if (objIt != m_object_list.end())
					{
						return (objIt++)->second;
					}
				}
			}

			// pool为空，返回空指针
			boost::shared_ptr<T> temp((T*)NULL);
			return temp;
		}

		template <class K, class T>
		boost::shared_ptr<T> ObjectSharedPtrMap2<K, T>::BeginObject(objectid64 iteratorId, K id)
		{
			{
				write_lock lock(m_object_list_lock);

				// 新加该id对应的迭代器
				m_it_list[iteratorId] = m_object_list.find(id);
				if (m_it_list[iteratorId] == m_object_list.end())
				{
					m_it_list[iteratorId] = m_object_list.begin();
				}

				// 根据id，查找对应迭代器iterator
				IteratorTypeIterator itIt = m_it_list.find(iteratorId);
				if (itIt != m_it_list.end())
				{
					// 得到T的迭代器
					MapTypeIterator& objIt = itIt->second;
					if (objIt != m_object_list.end())
					{
						return (objIt++)->second;
					}
				}
			}

			// pool为空，返回空指针
			boost::shared_ptr<T> temp((T*)NULL);
			return temp;
		}

		template <class K, class T>
		boost::shared_ptr<T> ObjectSharedPtrMap2<K, T>::NextObject(objectid64 iteratorId)
		{
			{
				write_lock lock(m_object_list_lock);

				// 根据id，查找对应迭代器iterator
				IteratorTypeIterator itIt = m_it_list.find(iteratorId);
				if (itIt != m_it_list.end())
				{
					// 得到T的迭代器
					MapTypeIterator& objIt = itIt->second;
					if (objIt != m_object_list.end())
					{
						return (objIt++)->second;
					}

					// 已迭代完毕，释放迭代器
					m_it_list.erase(itIt);
				}
			}

			// 已迭代完毕，返回空指针
			boost::shared_ptr<T> temp((T*)NULL);
			return temp;
		}

		template <class K, class T>
		void ObjectSharedPtrMap2<K, T>::EndObject(objectid64 iteratorId)
		{
			{
				write_lock lock(m_object_list_lock);

				// 根据id，查找对应迭代器iterator
				IteratorTypeIterator itIt = m_it_list.find(iteratorId);
				if (itIt != m_it_list.end())
				{
					// 释放迭代器
					m_it_list.erase(itIt);
				}
			}
		}

	}
}

#endif