细粒度锁队列是针对于对象进行一个加锁的过程。
细粒度锁队列是一种并发编程中常用的同步机制,用于解决多线程竞争问题,通过将一个共享资源划分为多个较小的部分,并为每个部分分配一个独立的锁来实现并发控制。
创建细粒度锁队列需要按照共享资源的逻辑结构进行划分,并为每个部分分配一个独立的锁。
可以通过自定义锁对象或者使用并发集合类中提供的锁来实现。
主要用途是提高并发性能。
在多线程环境中,当多个线程同时访问同一个共享资源时,会引发竞争条件,导致性能下降和数据不一致的问题。使用细粒度锁队列可以将资源的竞争范围缩小到更小的部分,减少了线程之间的竞争,提高了并发性能。
细粒度锁队列的使用场景包括但不限于以下几种情况:
1. 频繁访问的共享资源较多,使用粗粒度锁会导致过多的线程竞争,使用细粒度锁可以减小竞争范围,提高并发性能。
2. 共享资源的操作可以被并行进行,但是使用粗粒度锁会导致串行执行,使用细粒度锁可以让多个线程并发执行,提高吞吐量。
3. 共享资源的数据结构支持细粒度的操作,例如链表、哈希表等,通过细粒度锁队列可以实现更灵活和高效的并发控制。
综上所述,细粒度锁队列可以提高并发性能和吞吐量,减少线程竞争,保证数据的一致性。
但是需要注意的是,使用细粒度锁队列也可能引入额外的开销,导致复杂性增加,需要在实际应用中权衡使用。
简单案例
#include <iostream>
#include <mutex>
#include <thread>
#include <new>
#include <vector>
using namespace std;
template<class T>
class Thread_safe_Quene
{
public:
Thread_safe_Quene():head(new Node),tail(head.get()){}
Thread_safe_Quene(const Thread_safe_Quene& other) = delete;
Thread_safe_Quene& operator=(const Thread_safe_Quene& other) = delete;
void PushValue(T newValue)
{
shared_ptr<T> newData(make_shared<T>(newValue));
unique_ptr<Node> p(new Node);
Node* const newTail = p.get();
lock_guard<mutex> tail_lock();
tail->data = newData;
tail->next = move(p);
tail = newTail;
}
shared_ptr<T> tryPop()
{
unique_ptr<Node> oldhead = popHead();
return oldhead ? oldhead->data : shared_ptr<T>();
}
private:
struct Node//节点里面用智能指针去进行管理
{
shared_ptr<T> data;
unique_ptr<Node> next;
};
//队列的特性是FIFO【先进先出】
mutex mtx_head; //表头的互斥量
mutex mtx_tail; //表尾的互斥量
unique_ptr<Node> head; //记录表头
Node* tail; //记录表尾
private:
Node* getTail()//获取表尾
{
lock_guard<mutex> tail_lock(mtx_tail);
return tail;
}
unique_ptr<Node> popHead()//出队,获取表头
{
lock_guard<mutex> head_lock(mtx_head);
if (head.get() == getTail())//空的,无法出队
{
return nullptr;
}
unique_ptr<Node> oldhead = move(head);
head = move(oldhead->next);
return oldhead;
}
};
void insertData(Thread_safe_Quene<int>& other, int data)
{
other.PushValue(data);
}
void popData(Thread_safe_Quene<int>& other)
{
shared_ptr<int> result = other.tryPop();
if (result==nullptr)
{
printf("noValue\n");
}
else
{
printf("%d\n", *result);
}
}
int main()
{
vector<thread> t;
Thread_safe_Quene<int> test1;
for (int i =0;i<5000;i++)
{
t.push_back(thread(insertData,ref(test1),i));
t.push_back(thread(popData,ref(test1)));
}
for (auto& v:t)
{
v.join();
}
return 0;
}