參考了 《c++併發程式設計實戰》這本書上的程式碼寫了一個執行緒安全可以併發的map

/*
 * threadsafe_map.cpp
 *
 *  Created on: May 11, 2018
 *      Author: clh01s
 *      執行緒安全的查詢表
 *      通過boost的shared_mutex實現讀寫鎖
 *      假設有一定數量的桶，每一個鍵都有一個桶
 *      這就意味著可以安全地為每一個桶分配一個獨立的鎖
 *      這樣一個桶就可以有1個併發N個桶就有N個併發
 */

#include <iostream>
#include <mutex>
#include <list>
#include <utility>//std::pair
#include <boost/thread/shared_mutex.hpp>//boost::shared_mutex
#include <vector>
#include <string>
#include <algorithm>    // std::find_if
#include <memory>
#include <functional>


template<typename Key,typename Value,typename Hash = std::hash<Key>>
class threadsafe_lookup_table
{
private:
	class bucket_type
	{
	public:
		//在這個函式讀取時將鎖鎖定
		Value value_for(Key const& key,Value const& default_value) const
		{
			boost::shared_lock<boost::shared_mutex> lock(_mutex);
			_bucket_const_iterator found_entry = find_entry_for(key);
//			std::cout<<"(found_entry == _data.end()) ? default_value : found_entry->second = "<<((found_entry == _data.end()) ? default_value : found_entry->second)<<std::endl;
			return (found_entry == _data.end()) ? default_value : found_entry->second;
		}

		//在修改時也將鎖鎖定
		void add_or_update_mapping(Key const& key,Value const& value)
		{
			std::unique_lock<boost::shared_mutex> lock(_mutex);
			_bucket_iterator found_entry = find_entry_for(key);
			if(found_entry == _data.end())
			{
				_data.push_back(_bucket_value(key,value));
			}
			else
			{
				//如果key已經存在就更新value
				found_entry->second = value;
			}
		}

		void remove_mapping(Key const& key)
		{
			std::unique_lock<boost::shared_mutex> lock(_mutex);
			_bucket_iterator const found_entry = find_entry_for(key);
			if(found_entry != _data.end())
			{
				_data.erase(found_entry);
			}
		}
	private:
		typedef std::pair<Key,Value> _bucket_value;
		typedef std::list<_bucket_value> _bucket_data;
		//const與非const版本的迭代器
		typedef typename _bucket_data::iterator _bucket_iterator;
		typedef typename _bucket_data::const_iterator _bucket_const_iterator;

		_bucket_data _data;
		//每一個桶都將被一個shared_mutex例項保護
		mutable boost::shared_mutex _mutex;

		//通過此函式確定是否有以key為關鍵字的桶可以用來存放資料
		//非const版本
		_bucket_iterator find_entry_for(Key const& key)
		{
			return std::find_if(_data.begin(),_data.end(),
			                [&](_bucket_value const& item)
			                {return item.first==key;});
		}

		//通過此函式確定是否有以key為關鍵字的桶可以用來存放資料
		//const版本
		_bucket_const_iterator find_entry_for(Key const& key) const
		{
			//由於要返回非const的迭代器所以將資料放置到非const變數返回
			return std::find_if(_data.begin(),_data.end(),
			                [&](_bucket_value const& item)
			                {return item.first==key;});
		}
	};

public:
	//持有桶的變數
	std::vector<std::unique_ptr<bucket_type> > buckets;
	Hash hasher;
	//獲取數量並不改變所以不需要鎖
	bucket_type& get_bucket(Key const& key) const
	{
		std::size_t const bucket_index = hasher(key) % buckets.size();
		std::cout<<"bucket_index = "<<bucket_index<<std::endl
				<<"hasher(key) = "<<hasher(key)<<std::endl
				<<"buckets.size() = "<<buckets.size()<<std::endl;
		return *buckets[bucket_index];
	}

public:
	typedef Key key_type;
	typedef Hash hash_type;
	//初始化數量，質數與雜湊效率最高所以選擇19初始化
	threadsafe_lookup_table(
			unsigned num_buckets = 19,Hash const& hasher_ = Hash()):
			buckets(num_buckets),hasher(hasher_)
	{
		for(unsigned i = 0;i < num_buckets;++i)
		{
			buckets[i].reset(new bucket_type);
		}
	}

	threadsafe_lookup_table(threadsafe_lookup_table const& other) = delete;

	threadsafe_lookup_table const& operator=(
			threadsafe_lookup_table const& other) = delete;

	Value value_for(Key const& key,Value const& default_value = Value())
	{
		return get_bucket(key).value_for(key,default_value);
	}

	void remove_maping(Key const& key)
	{
		get_bucket(key).remove_mapping(key);
	}
};

int main()
{
	threadsafe_lookup_table<std::string,std::string> my_map;
	//通過get_bucket的引數key來選擇你需要往哪個桶中存放資料
	//再呼叫add_or_update_mapping來存放你的key和value
	my_map.get_bucket("a").add_or_update_mapping("a","aa");
	//呼叫value_for來獲得key值
	//你會發現value_for也需要key和value這是應為value_for的value是預設值用來確定返回的是否是真的key值如果是預設值就代表沒有查詢到
	std::cout<<"key a for value ="<<my_map.get_bucket("a").value_for("a","0")<<std::endl;
	return 0;
}
 

執行結果：

[email protected]:~/testcode/併發$ g++ threadsafe_map.cpp -std=c++11  -L/usr/local/lib -I/usr/local/include/boost/ -lboost_system -lboost_thread -g
[email protected]:~/testcode/併發$ ./a.out
bucket_index = 16
hasher(key) = 4993892634952068459
buckets.size() = 19
bucket_index = 16
hasher(key) = 4993892634952068459
buckets.size() = 19
key a for value =aa