C++并发编程----利用锁实现线程安全的数据结构（《C++ Concurrency in Action》 读书笔记）
本文为《C++ Concurrency in Action》 读书笔记，对其中的一些知识点进行总结。阅读这本书前建议先阅读《Effective C++》
线程安全队列
template<typename T>
class threadsafe_queue
{
private:
//一个链表节点，用链表最为队列的数据结构
struct node
{
std::shared_ptr<T> data;
std::unique_ptr<node> next;
};
//头节点互斥量
std::mutex head_mutex;
//头节点指针
std::unique_ptr<node> head;
//尾节点互斥量
std::mutex tail_mutex;
//尾节点指针，尾节点指针不能是unique_ptr，
//因为，对于尾节点会同时有两个指针指向它，他的前驱和tail指针,不能unique_ptr的的目的便是防止共享，
//所以,只能用一般的指针来指示尾节点
node* tail;
//条件变量，用于等待和唤醒操作
std::condition_variable data_cond;
/*
* 因为使用私有数据结构node，因此这些函数需要类内部实现
*/
//互斥得获取尾节点
node* get_tail() {
std::lock_guard<std::mutex> tail_lock(tail_mutex);
return tail;
}
//弹出头节点，只需要直接弹出，互斥以及判空有调用的函数保证
//抽象该函数可以避免代码重复
std::unique_ptr<node> pop_head() {
std::unique_ptr<node> old_head = std::move(head);
head = std::move(old_head->next);
return old_head;
}
//当有数据到达时唤醒一个线程，并让该线程持有头节点互斥量
std::unique_lock<std::mutex> wait_for_data() {
std::unique_lock<std::mutex> head_lock(head_mutex);
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();
}
public:
//该队列中将会有一个节点不存放数据，用于避免条件竞争，
//避免当队列中只有一个数据时，头指针和尾指针之间发生条件竞争
threadsafe_queue() :
head(new node), tail(head.get())
{}
threadsafe_queue(const threadsafe_queue& other) = delete;
threadsafe_queue& operator=(const threadsafe_queue&
other) = delete;
//push于类外实现
void push(T new_value);
//try_pop将不会阻塞等待数据的到达
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;//将会发生隐式类型转换
}
bool empty()
{
std::lock_guard<std::mutex> head_lock(head_mutex);
return (head.get() == get_tail());
}
//如果队为空，则线程将会阻塞等待，直到被唤醒
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);
}
};
//push，数据入队列
template<typename T>
void threadsafe_queue<T>::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();
}
用简单的消费者和生产者测试队列：
void fun1(threadsafe_queue<int> & que) {
for (int i = 0; i < 15; i++) {
que.push(i);
this_thread::sleep_for(std::chrono::milliseconds(1000));
}
}
void fun2(threadsafe_queue<int>& que) {
int i = 0;
while (i < 9) {
que.wait_and_pop(i);
cout <<"comsymer_1 get number:" <<i << endl;
}
}
void fun3(threadsafe_queue<int>& que) {
int i = 0;
while (i < 9) {
que.wait_and_pop(i);
cout << "comsymer_2 get number:" << i << endl;
}
}
int main() {
threadsafe_queue<int> que;
thread producer(fun1,ref(que));
thread comsumer_1(fun2,ref(que));
thread comsumer_2(fun3, ref(que));
producer.join();
comsumer_1.join();
comsumer_2.join();
return 0;
}
支持并发的Map
采用c++标程序库中的hash< typename T> 来设置哈希函数，每个桶由链表构成，每个Map中内嵌一个bucket的类。
template<typename Key, typename Value, typename Hash = std::hash<Key> >
class threadsafe_lookup_table
{
private:
//一个buket中存放相同的键（通过hansh函数计算后的函数值），
//对应的值（一个pair）存放于一个链表中。
class bucket_type
{
private:
typedef std::pair<Key, Value> bucket_value;
typedef std::list<bucket_value> bucket_data;
typedef typename bucket_data::iterator bucket_iterator;
mutable bucket_data data;// data 加上关键字mutable，因为需要在const修饰的函数中修改桶的类
mutable boost::shared_mutex mutex; // 允许多个线程同时读，但某个时刻仅一个线程可以修改
/*
*一个给定的key，返回该key对应的数据的迭代器
*/
bucket_iterator find_entry_for(Key const& key) const
{
auto it = std::find_if(data.begin(), data.end(),
[&](bucket_value const& item)
{return item.first == key; });
return it;
}
public:
/*
* 给定一个key，返回其对应的值
*/
Value value_for(Key const& key, Value const& default_value)
const
{
boost::shared_lock<boost::shared_mutex> lock(mutex); //可以多个同时读取数据
bucket_iterator const 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 const 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);
bucket_iterator const found_entry = find_entry_for(key);
if (found_entry != data.end())
{
data.erase(found_entry);
}
}
};
//用unique_ptr来管理bucket，使得不能有多个指针管理一个桶。
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();
return *buckets[bucket_index];
}
public:
typedef Key key_type;
typedef Value mapped_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& operator=(threadsafe_lookup_table const& other) = delete;
/*
* 更具key的值查找value
*/
Value value_for(Key const& key,
Value const& default_value = Value()) const
{
return get_bucket(key).value_for(key, default_value); // 8
}
/*
* 修改hash表的，插入或者更改
*/
void add_or_update_mapping(Key const& key, Value const& value)
{
get_bucket(key).add_or_update_mapping(key, value); // 9
}
/*
* 删除元素
*/
void remove_mapping(Key const& key)
{
get_bucket(key).remove_mapping(key); // 10
}
/*
* 用于备份map
*/
std::map<Key, Value> get_map() const
{
std::vector<std::unique_lock<boost::shared_mutex> > locks;
for (unsigned i = 0; i < buckets.size(); ++i)
{
locks.push_back(
std::unique_lock<boost::shared_mutex>(buckets[i].mutex));
}
std::map<Key, Value> res;
for (unsigned i = 0; i < buckets.size(); ++i)
{
for (auto it = buckets[i].data.begin();
it != buckets[i].data.end();
++it)
{
res.insert(*it);
}
}
return res;
}
};
线程安全的链表
template<typename T>
class threadsafe_list
{
struct node // 内嵌节点类
{
std::mutex m;
std::shared_ptr<T> data;
std::unique_ptr<node> next;
node() : // 2
next()
{}
node(T const& value) : // 3
data(std::make_shared<T>(value))
{}
};
node head;
public:
threadsafe_list()
{}
~threadsafe_list()
{
remove_if([](node const&) {return true; });//删除所有节点
}
//禁止拷贝成员的出现
threadsafe_list(threadsafe_list const& other) = delete;
threadsafe_list& operator=(threadsafe_list const&
other) = delete;
//push_front,采用头插法，因此每次仅需要获取头结点锁即可
//因为移除的操作需要获得头节点和下一个节点才会释放头节点锁，
//因此，不会出插入时获取头节点后，下一个节点被删除的情况
void push_front(T const& value)
{
std::unique_ptr<node> new_node(new node(value)); // 4
std::lock_guard<std::mutex> lk(head.m);
new_node->next = std::move(head.next); // 5
head.next = std::move(new_node); // 6
}
//传入谓词，对每个节点进行遍历。
//每次需要获取下一个节点的锁，才能释放上一个节点的锁
template<typename Function>
void for_each(Function f) // 7
{
node* current = &head;
std::unique_lock<std::mutex> lk(head.m); // 8
while (node* const next = current->next.get()) // 9
{
std::unique_lock<std::mutex> next_lk(next->m); // 10
lk.unlock(); // 11
f(*next->data); // 12
current = next;
lk = std::move(next_lk); // 13
}
}
template<typename Predicate>
std::shared_ptr<T> find_first_if(Predicate p) // 14
{
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)) // 15
{
return next->data; // 16
}
current = next;
lk = std::move(next_lk);
}
return std::shared_ptr<T>();
}
template<typename Predicate>
//删除一个需要同时锁住两个节点
void remove_if(Predicate p) // 17
{
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)) // 18
{
std::unique_ptr<node> old_next = std::move(current->next);
current->next = std::move(next->next);
next_lk.unlock();
} // 20
else
{
lk.unlock(); // 21
current = next;
lk = std::move(next_lk);
}
}
}
};