有锁队列（Lock-Based Queue） 是一种通过锁机制来实现线程安全的队列。在有锁队列中，锁的作用是保护共享资源（如队列的头节点、尾节点等），确保多个线程在访问队列时不会导致数据竞争或不一致的状态。
1. 入队操作（Enqueue）
在入队操作中，需要修改队列的尾节点（tail），因此需要在修改 tail 时加锁。
加锁位置：
-
在访问和修改
tail时加锁。 -
在释放锁之前完成新节点的插入。
伪代码：
void enqueue(int value) {
Node* newNode = new Node(value);
std::lock_guard<std::mutex> lock(queue_mutex); // 加锁
if (tail) {
tail->next = newNode;
} else {
head = newNode; // 如果队列为空，更新 head
}
tail = newNode; // 更新 tail
}2. 出队操作（Dequeue）
在出队操作中，需要修改队列的头节点（head），因此需要在修改 head 时加锁。
加锁位置：
-
在访问和修改
head时加锁。 -
在释放锁之前完成旧节点的移除。
-
伪代码：
bool dequeue(int& result) { std::lock_guard<std::mutex> lock(queue_mutex); // 加锁 if (head == nullptr) { return false; // 队列为空 } Node* oldHead = head; result = oldHead->value; head = head->next; if (head == nullptr) { tail = nullptr; // 如果队列为空，更新 tail } delete oldHead; // 释放旧节点 return true; }
-
3. 完整的有锁队列实现
以下是一个完整的有锁队列实现（基于链表）：
#include <iostream> #include <mutex> struct Node { int value; Node* next; Node(int val) : value(val), next(nullptr) {} }; class LockBasedQueue { public: LockBasedQueue() : head(nullptr), tail(nullptr) {} ~LockBasedQueue() { while (dequeue()) {} // 释放所有节点 } void enqueue(int value) { Node* newNode = new Node(value); std::lock_guard<std::mutex> lock(queue_mutex); // 加锁 if (tail) { tail->next = newNode; } else { head = newNode; // 如果队列为空，更新 head } tail = newNode; // 更新 tail } bool dequeue(int& result) { std::lock_guard<std::mutex> lock(queue_mutex); // 加锁 if (head == nullptr) { return false; // 队列为空 } Node* oldHead = head; result = oldHead->value; head = head->next; if (head == nullptr) { tail = nullptr; // 如果队列为空，更新 tail } delete oldHead; // 释放旧节点 return true; } private: Node* head; Node* tail; std::mutex queue_mutex; // 互斥锁 }; int main() { LockBasedQueue queue; queue.enqueue(1); queue.enqueue(2); int value; while (queue.dequeue(value)) { std::cout << "Dequeued: " << value << std::endl; } return 0; }4. 加锁的注意事项
-
锁的粒度：
-
锁的粒度越小，并发性能越高。
-
在有锁队列中，通常只需要在修改
head或tail时加锁。
-
-
死锁：
-
避免在加锁的情况下调用其他可能加锁的函数，否则可能导致死锁。
-
-
性能：
-
锁的开销较大，尤其是在高并发场景中，可能会成为性能瓶颈。
-
-
实现简单：通过锁机制可以很容易地实现线程安全。
-
易于理解：加锁的逻辑直观，适合初学者。
-
性能瓶颈：锁的开销较大，尤其是在高并发场景中。
-
死锁风险：如果锁的使用不当，可能导致死锁。
-
扩展性差：锁的粒度较大时，难以扩展到多核或多线程环境。
5. 有锁队列的优缺点
优点
-
实现简单：通过锁机制可以很容易地实现线程安全。
-
易于理解：加锁的逻辑直观，适合初学者。
缺点
-
性能瓶颈：锁的开销较大，尤其是在高并发场景中。
-
死锁风险：如果锁的使用不当，可能导致死锁。
-
扩展性差：锁的粒度较大时，难以扩展到多核或多线程环境。
6. 有锁队列 vs 无锁队列
| 特性 | 有锁队列 | 无锁队列 |
|---|---|---|
| 实现复杂度 | 简单 | 复杂 |
| 性能 | 低并发性能较好，高并发性能较差 | 高并发性能较好 |
| 死锁风险 | 有 | 无 |
| 适用场景 | 低并发场景 | 高并发场景 |
7. 总结
在有锁队列中，加锁的位置通常是在修改队列的头节点（head）或尾节点（tail）时。通过合理地加锁，可以确保队列的线程安全性。尽管有锁队列实现简单，但在高并发场景中，锁的开销可能成为性能瓶颈，此时可以考虑使用无锁队列。
1. 无锁队列是什么？
无锁队列（Lock-Free Queue）是一种并发数据结构，允许多个线程在不使用锁的情况下安全地进行入队（enqueue）和出队（dequeue）操作。它的核心思想是通过 原子操作 来确保数据的一致性，而不是通过锁来保护共享资源。
无锁队列的特点：
-
无阻塞：线程不会因为竞争资源而被阻塞。
-
高并发性：避免了锁的开销，适合高并发场景。
-
复杂性：实现比基于锁的队列更复杂，需要处理更多的边界条件。
2. 为什么需要无锁队列？
在传统的 有锁队列 中，多个线程需要通过锁来保护共享资源（如队列的头节点和尾节点）。锁的缺点是：
-
性能瓶颈：锁的开销较大，尤其是在高并发场景中。
-
死锁风险：如果锁的使用不当，可能导致死锁。
无锁队列通过原子操作避免了锁的开销，提高了并发性能。
3. 原子操作是什么？
原子操作（Atomic Operation）是指一个操作要么完全执行，要么完全不执行，不会被其他线程中断或干扰。原子操作是线程安全的，能够确保在多线程环境下对共享数据的操作不会导致数据竞争（Data Race）或不一致的状态。
原子操作的核心特性：
-
不可分割性：原子操作在执行过程中不会被其他线程打断。
-
线程安全：多个线程同时执行原子操作时，不会导致数据不一致。
4. C++ 中的 std::atomic
C++11 引入了 <atomic> 头文件，提供了对原子操作的支持。std::atomic 是一个模板类，可以将普通变量（如 int、bool、指针等）包装成原子变量。
示例：
#include <atomic>
#include <iostream>
int main() {
std::atomic<int> counter(0); // 原子变量
counter.fetch_add(1); // 原子操作：加 1
std::cout << "Counter: " << counter.load() << std::endl; // 原子操作：读取值
return 0;
}-
常用操作：
-
load()：原子地读取值。 -
store()：原子地写入值。 -
fetch_add()：原子地加一个值。 -
fetch_sub()：原子地减一个值。 -
compare_exchange_weak()：比较并交换（CAS）。
5. 无锁队列的实现
无锁队列通常基于 链表 或 环形缓冲区 实现。以下是基于链表的无锁队列的简单实现思路：
数据结构
struct Node {
int value;
std::atomic<Node*> next; // 原子指针
Node(int val) : value(val), next(nullptr) {}
};
class LockFreeQueue {
private:
std::atomic<Node*> head; // 队头
std::atomic<Node*> tail; // 队尾
};入队操作（Enqueue）
-
创建一个新节点。
-
使用 CAS 操作将新节点添加到队尾。
-
如果 CAS 失败，重试直到成功。
出队操作（Dequeue）
-
使用 CAS 操作移除队头节点。
-
如果 CAS 失败，重试直到成功。
6. 无锁队列的代码示例
以下是一个简单的无锁队列实现（基于链表）：
#include <atomic>
#include <iostream>
struct Node {
int value;
std::atomic<Node*> next;
Node(int val) : value(val), next(nullptr) {}
};
class LockFreeQueue {
public:
LockFreeQueue() {
Node* dummy = new Node(-1); // 哨兵节点
head = dummy;
tail = dummy;
}
~LockFreeQueue() {
while (dequeue()) {} // 释放所有节点
delete head.load();
}
void enqueue(int value) {
Node* newNode = new Node(value);
while (true) {
Node* currTail = tail.load();
Node* tailNext = currTail->next.load();
// 检查 tail 是否被其他线程修改
if (currTail == tail.load()) {
if (tailNext == nullptr) {
// 尝试将新节点添加到队尾
if (currTail->next.compare_exchange_weak(tailNext, newNode)) {
// 更新 tail
tail.compare_exchange_weak(currTail, newNode);
return;
}
} else {
// 帮助其他线程完成 tail 更新
tail.compare_exchange_weak(currTail, tailNext);
}
}
}
}
bool dequeue(int& result) {
while (true) {
Node* currHead = head.load();
Node* currTail = tail.load();
Node* headNext = currHead->next.load();
// 检查 head 是否被其他线程修改
if (currHead == head.load()) {
if (currHead == currTail) {
// 队列为空
if (headNext == nullptr) {
return false;
}
// 帮助其他线程完成 tail 更新
tail.compare_exchange_weak(currTail, headNext);
} else {
// 尝试移除队头节点
result = headNext->value;
if (head.compare_exchange_weak(currHead, headNext)) {
delete currHead; // 释放旧头节点
return true;
}
}
}
}
}
private:
std::atomic<Node*> head;
std::atomic<Node*> tail;
};
int main() {
LockFreeQueue queue;
queue.enqueue(1);
queue.enqueue(2);
int value;
while (queue.dequeue(value)) {
std::cout << "Dequeued: " << value << std::endl;
}
return 0;
}7. 代码解析
-
Node结构：-
包含
value和next指针。 -
next是原子指针，确保多线程环境下的线程安全。
-
-
LockFreeQueue类：-
head和tail是原子指针，分别指向队头和队尾。 -
enqueue和dequeue使用 CAS 操作实现无锁的入队和出队。
-
-
CAS 操作：
-
compare_exchange_weak是 CAS 的实现，用于原子地比较并交换值。 -
如果当前值等于预期值，则更新为新值；否则，重试。
-
8. 无锁队列的优缺点
优点
-
高并发性：避免了锁的开销，适合高并发场景。
-
无死锁：没有锁，自然不会有死锁问题。
缺点
-
实现复杂：需要处理更多的边界条件和竞争条件。
-
ABA 问题：在 CAS 操作中，可能会遇到 ABA 问题（即一个值从 A 变成 B 又变回 A，CAS 无法检测到中间的变化）。
9. 总结
-
无锁队列通过原子操作实现线程安全，避免了锁的开销。
-
std::atomic是 C++ 中实现原子操作的工具，能够确保多线程环境下的数据一致性。 -
无锁队列的实现复杂，但在高并发场景中具有显著的优势。
扫一扫
1641
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
