C++11:基于std::unordered_map和共享锁构建线程安全的map
前一篇博客《C++11:基于std::queue和std::mutex构建一个线程安全的队列》中，实现了一个线程安全的队列，本文说说如何实现一个线程安全的map。
在上一篇博客中，实现threadsafe_queue主要是依赖std::mutex信号量来实现线程对threadsafe_queue的独占访问,不论是只读的函数还是写函数对threadsafe_queue都是独占访问,因为对threadsafe_queue中的操作相对较少，而且主要操作push/pop都是写操作,所以这样做是没问题的。
但对于map,除了insert/erase这样的写操作之外还有find这样的读取操作,如果每个线程都是独占访问，无疑是会影响效率的。
所以在实现线程安全的map时,我没有选择使用std::mutex控制所有的操作为独占访问，而是用RWLock来控制map对象的访问，RWLock是我以前自己写的一个类，将线程对资源的访问分为读取操作和写入操作两类，这两类操作是独占的，但允许多个线程读取操作，允许一个线程写访问。也就是说多个线程在读取操作的时候，要写入的线程是阻塞的，直到所读取操作线程执行完读取操作释放读取锁，反之亦然，如果有一个线程在执行写入操作，所有要读取操作的线程就得等着，直到写入操作结束。
关于RWLock的源码及更详细的说明参见我的博客《无锁编程:c++11基于atomic实现共享读写锁(写优先)》
有了RWLock,基于std::unordered_map实现线程安全的map就比较简单了，基本上是把unordered_map的源码抄了一遍，对于unordered_map中的每个函数入口加一个RWLock的读取锁或写入锁。
实现的基本原则很简单:
对于const函数加读取锁，允许共享读取，
对于非const函数，加写入锁，允许独占写入。
下面是完整的源码:
/* * threadsafe_unordered_map.h * * Created on: 2016年7月26日 * Author: guyadong */
#ifndef COMMON_SOURCE_CPP_THREADSAFE_UNORDERED_MAP_H_
#define COMMON_SOURCE_CPP_THREADSAFE_UNORDERED_MAP_H_
#include __l,
size_type __n = 0,
const hasher& __hf = hasher(),
const key_equal& __eql = key_equal(),
const allocator_type& __a = allocator_type()):map(__l,__n,__hf,__eql,__a){}
threadsafe_unordered_map(size_type __n, const allocator_type& __a)
: threadsafe_unordered_map(__n, hasher(), key_equal(), __a){}
threadsafe_unordered_map(size_type __n, const hasher& __hf,
const allocator_type& __a)
: threadsafe_unordered_map(__n, __hf, key_equal(), __a){}
template<typename _InputIterator>
threadsafe_unordered_map(_InputIterator __first, _InputIterator __last,
size_type __n,
const allocator_type& __a):map(__first,__last,__n,__a){}
template<typename _InputIterator>
threadsafe_unordered_map(_InputIterator __first, _InputIterator __last,
size_type __n, const hasher& __hf,
const allocator_type& __a)
: threadsafe_unordered_map(__first, __last, __n, __hf, key_equal(), __a){}
threadsafe_unordered_map(initializer_list __l,
size_type __n,
const allocator_type& __a)
: threadsafe_unordered_map(__l, __n, hasher(), key_equal(), __a){}
threadsafe_unordered_map(initializer_list __l,
size_type __n, const hasher& __hf,
const allocator_type& __a)
: threadsafe_unordered_map(__l, __n, __hf, key_equal(), __a){}
bool empty() const noexcept{
auto guard=lock.read_guard();
return map.empty();
}
size_type size() const noexcept{
auto guard=lock.read_guard();
return map.size();
}
size_type max_size() const noexcept{
auto guard=lock.read_guard();
return map.max_size();
}
iterator begin() noexcept{
auto guard=lock.write_guard();
return map.begin();
}
const_iterator begin() const noexcept{
auto guard=lock.read_guard();
return map.begin();
}
const_iterator cbegin() const noexcept{
auto guard=lock.read_guard();
return map.cbegin();
}
iterator end() noexcept{
auto guard=lock.write_guard();
return map.end();
}
const_iterator end() const noexcept{
auto guard=lock.read_guard();
return map.end();
}
const_iterator cend() const noexcept{
auto guard=lock.read_guard();
return map.cend();
}
template<typename... _Args>
std::pairbool>
emplace(_Args&&... __args){
auto guard=lock.write_guard();
return map.emplace(std::forward<_Args>(__args)...);
}
template<typename... _Args>
iterator
emplace_hint(const_iterator __pos, _Args&&... __args){
auto guard=lock.write_guard();
return map.emplace_hint(__pos, std::forward<_Args>(__args)...);
}
std::pairbool> insert(const value_type& __x){
auto guard=lock.write_guard();
return map.insert(__x);
}
template<typename _Pair, typename = typename
std::enable_if<std::is_constructible::value>::type>
std::pairbool>
insert(_Pair&& __x){
auto guard=lock.write_guard();
return map.insert(std::forward<_Pair>(__x));
}
iterator
insert(const_iterator __hint, const value_type& __x) {
auto guard=lock.write_guard();
return map.insert(__hint, __x);
}
template<typename _Pair, typename = typename
std::enable_if<std::is_constructible::value>::type>
iterator
insert(const_iterator __hint, _Pair&& __x){
auto guard=lock.write_guard();
return map.insert(__hint, std::forward<_Pair>(__x));
}
template<typename _InputIterator>
void
insert(_InputIterator __first, _InputIterator __last){
auto guard=lock.write_guard();
map.insert(__first, __last);
}
void insert(initializer_list __l){
auto guard=lock.write_guard();
map.insert(__l);
}
iterator erase(const_iterator __position){
auto guard=lock.write_guard();
return map.erase(__position);
}
iterator erase(iterator __position){
auto guard=lock.write_guard();
return map.erase(__position);
}
size_type erase(const key_type& __x){
auto guard=lock.write_guard();
return map.erase(__x);
}
iterator erase(const_iterator __first, const_iterator __last){
auto guard=lock.write_guard();
return map.erase(__first, __last);
}
void clear() noexcept{
auto guard=lock.write_guard();
map.clear();
}
void swap(map_type& __x) noexcept( noexcept(map.swap(__x._M_h)) ){
auto guard=lock.write_guard();
map.swap(__x._M_h);
}
hasher hash_function() const{
auto guard=lock.read_guard();
return map.hash_function();
}
key_equal key_eq() const{
auto guard=lock.read_guard();
return map.key_eq();
}
iterator find(const key_type& __x){
auto guard=lock.write_guard();
return map.find(__x);
}
const_iterator find(const key_type& __x) const{
auto guard=lock.read_guard();
return map.find(__x);
}
size_type count(const key_type& __x) const {
auto guard=lock.read_guard();
return map.count(__x);
}
std::pair equal_range(const key_type& __x){
auto guard=lock.write_guard();
return map.equal_range(__x);
}
std::pair
equal_range(const key_type& __x) const{
auto guard=lock.read_guard();
return map.equal_range(__x);
}
mapped_type& operator[](const key_type& __k){
auto guard=lock.write_guard();
return map[__k];
}
mapped_type& operator[](key_type&& __k){
auto guard=lock.write_guard();
return map[std::move(__k)];
}
mapped_type& at(const key_type& __k){
auto guard=lock.write_guard();
return map.at(__k);
}
const mapped_type& at(const key_type& __k) const{
auto guard=lock.read_guard();
return map.at(__k);
}
size_type bucket_count() const noexcept{
auto guard=lock.read_guard();
return map.bucket_count();
}
size_type max_bucket_count() const noexcept{
auto guard=lock.read_guard();
return map.max_bucket_count();
}
size_type bucket_size(size_type __n) const{
auto guard=lock.read_guard();
return map.bucket_size(__n);
}
size_type bucket(const key_type& __key) const{
auto guard=lock.read_guard();
return map.bucket(__key);
}
local_iterator begin(size_type __n) {
auto guard=lock.write_guard();
return map.begin(__n);
}
const_local_iterator begin(size_type __n) const {
auto guard=lock.read_guard();
return map.begin(__n);
}
const_local_iterator cbegin(size_type __n) const{
auto guard=lock.read_guard();
return map.cbegin(__n);
}
local_iterator end(size_type __n) {
auto guard=lock.write_guard();
return map.end(__n);
}
const_local_iterator end(size_type __n) const{
auto guard=lock.read_guard();
return map.end(__n);
}
const_local_iterator cend(size_type __n) const{
auto guard=lock.read_guard();
return map.cend(__n);
}
float load_factor() const noexcept{
auto guard=lock.read_guard();
return map.load_factor();
}
float max_load_factor() const noexcept{
auto guard=lock.read_guard();
return map.max_load_factor();
}
void max_load_factor(float __z){
auto guard=lock.write_guard();
map.max_load_factor(__z);
}
void rehash(size_type __n){
auto guard=lock.write_guard();
map.rehash(__n);
}
void reserve(size_type __n){
auto guard=lock.write_guard();
map.reserve(__n);
}
/* * 新增加函数,bool值返回是否找到 * 返回true时,将value中置为找到的值 * */
bool find(const key_type& __x, mapped_type &value) const{
auto guard=lock.read_guard();
auto itor=map.find(__x);
auto found=itor!=map.end();
if(found)
value=itor->second;
return found;
}
/* * 新增加函数,返回读取锁的RAII对象 * 在对map进行读取操作时应该先调用此函数 * */
raii read_guard()const noexcept{
return lock.read_guard();
}
/* * 新增加函数,返回写入锁的RAII对象 * 在对map进行写入操作时应该先调用此函数 * */
raii write_guard()noexcept{
return lock.write_guard();
}
/* * 新增加函数 * 如果指定的key不存在，则增加key->value映射 * 如果指定的key存在返回key映射的值,否则返回value * */
mapped_type insertIfAbsent(const key_type& key,const mapped_type &value){
auto guard=lock.write_guard();
auto itor=map.find(key);
if (itor==map.end()){
map.insert(value_type(key, value));
return value;
}
return itor->second;
}
/* * 新增加函数 * 如果指定的key存在，则用value替换key映射的值,返回key原来映射的值 * 否则返回nullptr * */
std::shared_ptr replace(const key_type& key,const mapped_type &value){
auto guard=lock.write_guard();
if (map.find(key)!=map.end()){
map.insert(value_type(key, value));
return std::make_shared(value);
}
return std::shared_ptr();
}
/* * 新增加函数 * 如果存在key->value映射，则用newValue替换key映射的值,返回true * 否则返回false * */
bool replace(const key_type& key,const mapped_type &value,const mapped_type &newValue){
auto guard=lock.write_guard();
auto itor=map.find(key);
if (itor!=map.end()&&itor->second==value){
map.insert(value_type(key, newValue));
return true;
}
return false;
}
template<typename _Key1, typename _Tp1, typename _Hash1, typename _Pred1,
typename _Alloc1>
friend bool
operator==(const threadsafe_unordered_map<_Key1, _Tp1, _Hash1, _Pred1, _Alloc1>&,
const threadsafe_unordered_map<_Key1, _Tp1, _Hash1, _Pred1, _Alloc1>&);
};
template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
inline bool
operator==(const threadsafe_unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
const threadsafe_unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
{
auto guardx=__x.lock.read_guard();
auto guardy=__y.lock.read_guard();
return __x.map._M_equal(__y.map);
}
template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
inline bool
operator!=(const threadsafe_unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
const threadsafe_unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
{
auto guardx=__x.lock.read_guard();
auto guardy=__y.lock.read_guard();
return !(__x == __y);
}
}/* namespace mt */
}/* namespace gdface */
#endif /* COMMON_SOURCE_CPP_THREADSAFE_UNORDERED_MAP_H_ */ 说明:
因为RWLock禁止复制构造函数和赋值操作符,所以threadsafe_unordered_map也禁止复制构造函数和赋值操作符。
另外在类中增加几个用于多线程环境的函数(见源码中的中文注释),
当你需要对map加锁时需要用到raii write_guard()noexcept和raii read_guard()const noexcept。关于这两个函数返回的raii类参见我另一篇博客《C++11实现模板化(通用化)RAII机制》
而bool find(const key_type& __x, mapped_type &value) const则用于多线程环境查找__x对应的值。
下面三个新增加函数是参照java中ConcurrentMap接口实现的
mapped_type insertIfAbsent(const key_type& key,const mapped_type &value);
std::shared_ptr replace(const key_type& key,const mapped_type &value);
bool replace(const key_type& key,const mapped_type &value,const mapped_type &newValue)