文章目录
- 0. 概要
- 1. 实例代码
- 2. 线程安全机制与智能指针
- 3. 安全与非安全消费者线程设计对比
- 4. 跨模块传递`std::weak_ptr`的一致性与循环引用预防
- 5. 执行结果
0. 概要
[前置阅读] C++编程：使用std::weak_ptr监控std::shared_ptr
为了展示竞态条件的可能性，并且验证更安全的代码是如何避免这种竞态条件的，可以创建一个简单的多线程测试程序。
我们将使用一个生产者-消费者模型，其中生产者向队列中添加带有 std::shared_ptr 的事件，而消费者则从队列中取出事件并处理它们。
我们将实现两个版本：
- 不安全版本：不检查
std::shared_ptr是否有效 - 安全的版本：消费者线程在持有锁的情况下检查
std::shared_ptr的有效性。
1. 实例代码
以下是一个使用 C++11 标准库编写的测试程序示例：
#include <atomic>
#include <condition_variable>
#include <functional>
#include <iostream>
#include <memory>
#include <mutex>
#include <queue>
#include <thread>
#include <vector>
struct Event {
int id;
};
class EventQueue {
public:
void push_event(const Event &e, std::shared_ptr<void> ptr) {
std::unique_lock<std::mutex> lck(mtx_);
events_.push({e, std::weak_ptr<void>(ptr)});
cv_.notify_one();
}
void consume_events(
std::function<void(Event, std::shared_ptr<void>)> callback) {
std::unique_lock<std::mutex> lck(mtx_);
while (true) {
cv_.wait(lck, [this] { return !events_.empty() || stop_.load(); });
if (stop_.load()) {
break;
}
auto event_item = events_.front();
events_.pop();
#ifndef UN_SAFE
// 安全版本：在持有锁的情况下检查 shared_ptr 是否有效
if (const auto &shared_ptr = event_item.second.lock()) {
if (callback != nullptr) {
callback(event_item.first, shared_ptr);
}
}
#else
// 不安全版本：不检查 shared_ptr 是否有效
if (callback != nullptr) {
callback(event_item.first, event_item.second.lock());
}
#endif
}
}
void stop_consuming() {
stop_.store(true);
cv_.notify_all();
}
private:
std::queue<std::pair<Event, std::weak_ptr<void>>> events_;
std::mutex mtx_;
std::condition_variable cv_;
std::atomic<bool> stop_{false};
};
void producer(EventQueue &eq, int num_events) {
for (int i = 0; i < num_events; ++i) {
Event e{i};
std::shared_ptr<void> ptr(new int(i));
eq.push_event(e, ptr);
std::this_thread::sleep_for(std::chrono::milliseconds(1)); // 模拟耗时操作
}
}
void consumer(EventQueue &eq, int num_events) {
eq.consume_events([](Event e, std::shared_ptr<void> ptr) {
std::cout << "Event ID: " << e.id << ", Pointer valid: " << std::boolalpha
<< (ptr.get() != nullptr) << std::endl;
});
}
int main() {
// 不安全的代码设计，一般跑不了1000次循环测试。
static uint32_t count = 1;
while (count < 1000) {
EventQueue eq;
std::thread prod(producer, std::ref(eq), 10);
std::thread cons(consumer, std::ref(eq), 10);
prod.join();
eq.stop_consuming();
cons.join();
std::this_thread::sleep_for(std::chrono::milliseconds(100));
std::cout << "\n----- "
<< "count:" << count++ << " -----\n";
}
return 0;
}
2. 线程安全机制与智能指针
- 智能指针与互斥锁的协同工作：利用
std::lock_guard确保在持有互斥锁的情况下安全地操作std::shared_ptr，有效防止竞态条件的发生。 - 原子变量控制线程终止：在
stop_consuming()函数中，使用std::atomic<bool>类型的stop_变量来安全地控制消费者线程的终止，保证线程间通信的原子性。 - 生产者-消费者模式下的线程安全：生产者线程通过
push_event向事件队列添加事件，消费者线程则使用consume_events处理事件，确保所有操作在多线程环境下既安全又高效。
3. 安全与非安全消费者线程设计对比
-
测试代码的核心部分：
#ifndef UN_SAFE // 安全版本：在持有锁的情况下检查 shared_ptr 是否有效 if (const auto &shared_ptr = event_item.second.lock()) { if (callback != nullptr) { callback(event_item.first, shared_ptr); } } #else // 不安全版本：不检查 shared_ptr 是否有效 if (callback != nullptr) { callback(event_item.first, event_item.second.lock()); } #endif -
非安全实现的问题：当
#ifdef UN_SAFE条件下，消费者线程在持有互斥锁时直接调用event_item.second.lock()来获取shared_ptr，并将其作为参数传递给回调函数callback，但缺乏对shared_ptr是否为nullptr的检查。这可能导致在对象已被销毁的情况下访问空shared_ptr，引发未定义行为或程序崩溃。 -
安全实现的策略：通过先检查
shared_ptr的有效性再调用回调函数的方法，确保资源在被访问前仍然有效。具体做法是：if (const auto &shared_ptr = event_item.second.lock()) { if (callback != nullptr) { callback(event_item.first, shared_ptr); } }这样一来，即使在事件处理期间与该事件关联的对象被销毁，也不会导致空指针访问或悬空引用的情况发生。
weak_ptr_150">4. 跨模块传递std::weak_ptr的一致性与循环引用预防
- 跨模块传递的挑战与解决方案：在不同模块间传递
std::weak_ptr时，重要的是确保它们引用的是相同的控制块。为了解决这个问题，可以共享同一个std::shared_ptr实例，或者显式地传递以确保控制块的一致性。 - 选择
std::weak_ptr而非std::shared_ptr的原因：- 避免循环引用：如果事件类型内部已经使用了
std::shared_ptr，那么在事件队列中继续使用std::shared_ptr可能会形成循环引用，阻碍资源的正常释放。 - 延迟强引用提升：消费者线程在处理事件时可以根据需要通过
lock()方法升级std::weak_ptr为std::shared_ptr，这样避免了不必要的强引用创建和维持，提高了性能和资源管理效率。
- 避免循环引用：如果事件类型内部已经使用了
5. 执行结果
- 测试
不安全代码
使用如下命令编译和执行,在第55次的时候出现了错误
g++ -o unsafe test.cpp -lpthread -DUN_SAFE -O2
./unsafe
- 测试
安全代码
g++ -o unsafe test.cpp -lpthread -O2
./unsafe
在运行1000多次后，一次错误均未发生。
