基于锁的并发数据结构
1. 使用细粒度锁和条件变量的线程安全队列
可以使用细粒度的锁来减小队列的临界区，这里使用了一个dummy node用来进一步减小锁的临界区。若要判断队列是否为空，只需要执行下述判断：
head.get() == get_tail()
请注意，因为在进行push的时候需要修改tail，所以对tail的访问和修改都需要进行加锁。这里使用get_tail来封装这个操作，将锁的粒度减小到最低。
// lock tail mutex and return tail node
node *get_tail()
{
std::lock_guard<std::mutex> tail_lock(tail_mutex);
return tail;
}
对push的操作只涉及到修改tail节点，所以只需要对tail节点进行加锁。加锁完成之后就可以修改tail使其指向新的tail节点。
void push(T new_value)
{
std::shared_ptr<T> new_data(std::make_shared<T>(std::move(new_value)));
std::unique_ptr<node> p(new node);
{
std::lock_guard<std::mutex> tail_lock(tail_mutex);
tail->data = new_data;
node *const new_tail = p.get();
tail->next = std::move(p);
tail = new_tail;
}
data_cond.notify_one();
}
至于try_pop_head()为了应对这一种需求，如果队列为空直接返回，不等待。其操作如下所示：
std::unique_ptr<node> try_pop_head()
{
std::lock_guard<std::mutex> head_lock(head_mutex);
if (head.get() == get_tail())
{
return std::unique_ptr<node>();
}
return pop_head();
}
至于wait_and_pop()需要一直等待，直到弹出队列中的一个元素。这里使用了条件变量，避免线程循环进行空等待。当然，在push()的时候，需要配合条件变量通知等待的线程。
std::shared_ptr<T> wait_and_pop()
{
std::unique_ptr<node> const old_head = wait_pop_head();
return old_head->data;
}
std::unique_ptr<node> wait_pop_head()
{
std::unique_lock<std::mutex> head_lock(wait_for_data());
return pop_head();
}
// wait for data, return std::unique_lock<std::mutex> head_lock
std::unique_lock<std::mutex> wait_for_data()
{
std::unique_lock<std::mutex> head_lock(head_mutex);
// wait until not empty
data_cond.wait(head_lock, [&] { return head.get() != get_tail(); });
return std::move(head_lock);
}
完整的代码如下所示：
#pragma once
#include <memory>
#include <mutex>
template<typename T>
class threadsafe_queue
{
public:
threadsafe_queue() :
head(new node), tail(head.get()) {}
std::shared_ptr<T> try_pop()
{
std::unique_ptr<node> old_head = try_pop_head();
return old_head ? old_head->data : std::shared_ptr<T>();
}
bool try_pop(T &value)
{
std::unique_ptr<node> const old_head = try_pop_head(value);
return old_head.get();
}
std::shared_ptr<T> wait_and_pop()
{
std::unique_ptr<node> const old_head = wait_pop_head();
return old_head->data;
}
void wait_and_pop(T &value)
{
std::unique_ptr<node> const old_head = wait_pop_head(value);
}
void push(T new_value)
{
std::shared_ptr<T> new_data(std::make_shared<T>(std::move(new_value)));
std::unique_ptr<node> p(new node);
{
std::lock_guard<std::mutex> tail_lock(tail_mutex);
tail->data = new_data;
node *const new_tail = p.get();
tail->next = std::move(p);
tail = new_tail;
}
data_cond.notify_one();
}
bool empty()
{
std::lock_guard<std::mutex> head_lock(head_mutex);
return (head.get() == get_tail());
}
threadsafe_queue(const threadsafe_queue &) = delete;
threadsafe_queue &operator=(const threadsafe_queue &) = delete;
private:
struct node
{
std::shared_ptr<T> data;
std::unique_ptr<node> next;
};
// lock tail mutex and return tail node
node *get_tail()
{
std::lock_guard<std::mutex> tail_lock(tail_mutex);
return tail;
}
// pop head node from queue, return old head node
std::unique_ptr<node> pop_head()
{
std::unique_ptr<node> old_head = std::move(head);
head = std::move(old_head->next);
return old_head;
}
// wait for data, return std::unique_lock<std::mutex> head_lock
std::unique_lock<std::mutex> wait_for_data()
{
std::unique_lock<std::mutex> head_lock(head_mutex);
// wait until not empty
data_cond.wait(head_lock, [&] { return head.get() != get_tail(); });
return std::move(head_lock);
}
std::unique_ptr<node> wait_pop_head()
{
std::unique_lock<std::mutex> head_lock(wait_for_data());
return pop_head();
}
std::unique_ptr<node> wait_pop_head(T& value)
{
std::unique_lock<std::mutex> head_lock(wait_for_data());
value = std::move(*head->data);
return pop_head();
}
std::unique_ptr<node> try_pop_head()
{
std::lock_guard<std::mutex> head_lock(head_mutex);
if (head.get() == get_tail())
{
return std::unique_ptr<node>();
}
return pop_head();
}
std::unique_ptr<node> try_pop_head(T &value)
{
std::lock_guard<std::mutex> head_lock(head_mutex);
if (head.get() == get_tail())
{
return std::unique_ptr<node>();
}
value = std::move(*head->data);
return pop_head();
}
std::mutex head_mutex; // head mutex
std::unique_ptr<node> head; // head node
std::mutex tail_mutex; // tail mutex
node *tail; // tail node
std::condition_variable data_cond; // condition variable
};
2. 线程安全hash表
线程安全的hash表是另一个用于展示细粒度锁同步的很好的例子。在hash实现之中，使用了基于桶的开链hash实现。每个桶对应的链表可以统一使用同一个锁进行访问控制。对链表的修改需要使用写锁进行排他的访问控制，对链表的访问则使用读锁进行保护，这样就充分利用了读锁和写锁的区别，将锁的粒度降到最低，减少可能的数据竞争。
下面的代码展示了bucket_type的用法：
class bucket_type
{
public:
Value value_for(Key const& key, Value const& default_value) const
{
// read 需要加读锁
boost::shared_lock<boost::shared_mutex> lock(mutex);
const_bucket_iterator found_entry = find_entry_for(key);
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
{
found_entry->second = value;
}
}
void remove_mapping(Key const& key)
{
// 需要加写锁
std::unique_lock<boost::shared_mutex> lock(mutex);
const_bucket_iterator 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;
typedef typename bucket_data::const_iterator const_bucket_iterator;
typedef typename bucket_data::iterator bucket_iterator;
bucket_data data;
mutable boost::shared_mutex mutex;
const_bucket_iterator find_entry_for(Key const& key) const
{
return std::find_if(data.begin(),data.end(),
[&](bucket_value const& item)
{return item.first==key;});
}
bucket_iterator find_entry_for(Key const& key)
{
return std::find_if(data.begin(), data.end(), [&](bucket_value const& item) { return item.first == key; });
}
};
上述代码体现了读锁和写锁的区别，只有在修改链表的时候才使用写锁保证一致性，在访问链表的时候使用读锁来屏蔽写锁，允许同时访问。
多个hash桶就组合成了一个hash table。根据hash规则拿到对应的hash桶，再对桶内的链表进行读写操作。
std::vector<std::unique_ptr<bucket_type>> buckets;
//获取对应的hash桶
bucket_type& get_bucket(Key const& key) const
{
// 获取对应桶的操作不用进行加锁
std::size_t const bucket_index = hasher(key) % buckets.size();
return *buckets[bucket_index];
}
hash表剩余的操作就是对bucket内置函数的转调用。每个bucket有自己的读写锁进行访问控制。
Value value_for(Key const& key, Value const& default_value=Value()) const
{
return get_bucket(key).value_for(key, default_value);
}
void add_or_update_mapping(Key const& key, Value const& value)
{
get_bucket(key).add_or_update_mapping(key, value);
}
void remove_mapping(Key const& key)
{
get_bucket(key).remove_mapping(key);
}
3. 线程安全链表
对于线程安全的链表，也是用dummy node来标志链表的开头位置。注意对于遍历链表的操作，在对对应的链表节点进行操作的时候，一定要持有对应链表节点的锁，就像这样：
template<typename Function>
void for_each(Function f)
{
node* current = &head;
std::unique_lock<std::mutex> lk(head.m);
node* next;
while((next = current->next.get()) != NULL)
{
std::unique_lock<std::mutex> next_lk(next->m);
// unlock node
lk.unlock();
f(*next->data);
current=next;
lk = std::move(next_lk);
}
}
template<typename Predicate>
std::shared_ptr<T> find_first_if(Predicate p)
{
node* current = &head;
std::unique_lock<std::mutex> lk(head.m);
while(node* const next = current->next.get())
{
std::unique_lock<std::mutex> next_lk(next->m);
lk.unlock();
if(p(*next->data))
{
return next->data;
}
current = next;
lk = std::move(next_lk);
}
return std::shared_ptr<T>();
}
要注意的是，remove操作需要同时持有前后两个节点的锁，这样才能保证重新设置前后节点的时候对应节点不被修改。
template<typename Predicate>
void remove_if(Predicate p)
{
node* current = &head;
std::unique_lock<std::mutex> lk(head.m);
while(node* const next = current->next.get())
{
std::unique_lock<std::mutex> next_lk(next->m);
if(p(*next->data))
{
// store old_next node
// 保证old_next在析构之前其持有的锁已经被解锁
std::unique_ptr<node> old_next = std::move(current->next);
current->next = std::move(next->next);
next_lk.unlock();
}
else
{
lk.unlock();
current = next;
lk = std::move(next_lk);
}
}
}
对于整个链表的节点的析构也是借助remove_if完成的。
~threadsafe_list()
{
// remove all node from list
remove_if([](node const &){ return true; });
}
完整的链表实现代码如下所示：
#include <mutex>
template<typename T>
class threadsafe_list
{
public:
threadsafe_list()
{ }
~threadsafe_list()
{
// remove all node from list
remove_if([](node const &){ return true; });
}
// no copying
threadsafe_list(threadsafe_list&) = delete;
threadsafe_list& operator=(threadsafe_list&) = delete;
// push node in front of the list
void push_front(T const& value)
{
std::unique_ptr<node> new_node(new node(value));
std::lock_guard<std::mutex> lk(head.m);
new_node->next = std::move(head.next);
head.next = std::move(new_node);
}
template<typename Function>
void for_each(Function f)
{
node* current = &head;
std::unique_lock<std::mutex> lk(head.m);
node* next;
while((next = current->next.get()) != NULL)
{
std::unique_lock<std::mutex> next_lk(next->m);
// unlock node
lk.unlock();
f(*next->data);
current=next;
lk = std::move(next_lk);
}
}
template<typename Predicate>
std::shared_ptr<T> find_first_if(Predicate p)
{
node* current = &head;
std::unique_lock<std::mutex> lk(head.m);
while(node* const next = current->next.get())
{
std::unique_lock<std::mutex> next_lk(next->m);
lk.unlock();
if(p(*next->data))
{
return next->data;
}
current = next;
lk = std::move(next_lk);
}
return std::shared_ptr<T>();
}
template<typename Predicate>
void remove_if(Predicate p)
{
node* current = &head;
std::unique_lock<std::mutex> lk(head.m);
while(node* const next = current->next.get())
{
std::unique_lock<std::mutex> next_lk(next->m);
if(p(*next->data))
{
// store old_next node
// 保证old_next在析构之前其持有的锁已经被解锁
std::unique_ptr<node> old_next = std::move(current->next);
current->next = std::move(next->next);
next_lk.unlock();
}
else
{
lk.unlock();
current = next;
lk = std::move(next_lk);
}
}
}
private:
struct node
{
std::mutex m;
std::shared_ptr<T> data;
std::unique_ptr<node> next;
node():
m(),
data(),
next()
{ }
node(T const& value):
m(),
data(std::make_shared<T>(value)),
next()
{ }
};
// dummy node, store node data
node head;
};
《C++ 并发编程实战》
我的github:
https://github.com/zhoudayang
