C++传统并发控制多依赖互斥锁、读写锁等同步原语，这类方式需要开发者手动处理加锁解锁逻辑，很容易出现死锁、锁竞争过度等问题，增加代码维护难度。软件事务内存STM提供了一种更友好的并发编程范式，让代码块像事务一样执行，要么全部成功，要么失败回滚，无需手动管理锁。
软件事务内存的核心概念
STM的核心思想是模拟数据库事务的ACID特性，在并发场景中适配内存操作：
- 原子性：事务内的所有内存操作要么全部完成，要么全部不生效，不会出现部分执行的中间状态
- 一致性：事务执行前后，共享数据始终处于合法的状态
- 隔离性：未提交的事务修改对其他事务不可见，避免脏读问题
- 持久性：内存场景下的持久性通常指事务提交后修改永久生效，不会丢失
C++实现简易STM的核心思路
实现一个基础可用的STM需要解决三个核心问题：事务上下文管理、共享变量代理、冲突检测与回滚。下面我们逐步拆解实现逻辑。
1. 事务上下文设计
每个事务需要独立的上下文记录自己的读集、写集和执行状态，我们可以用一个结构体来管理这些信息：
#include <iostream>
#include <unordered_map>
#include <vector>
#include <functional>
#include <memory>
#include <cassert>
// 事务状态枚举
enum class TransactionState {
ACTIVE, // 正在执行
COMMITTED,// 已提交
ABORTED // 已中止
};
// 事务上下文结构体
struct TransactionContext {
TransactionState state = TransactionState::ACTIVE;
// 读集：记录读取的共享变量地址和读取时的值
std::unordered_map<void*, std::shared_ptr<void>> read_set;
// 写集：记录要修改的共享变量地址和待写入的值
std::unordered_map<void*, std::shared_ptr<void>> write_set;
};
2. 共享变量代理类
为了让STM能拦截对共享变量的读写操作，我们需要给共享变量包装一个代理类，所有访问都通过代理类进行，这样STM才能记录读写集：
// 共享变量代理模板类
template <typename T>
class StmVariable {
private:
T value; // 实际存储的值
// 全局事务上下文，实际实现中可以用线程局部变量存储当前事务
static TransactionContext* current_tx;
public:
StmVariable(T init_val) : value(init_val) {}
// 读取操作，记录到读集
T read() {
if (current_tx && current_tx->state == TransactionState::ACTIVE) {
// 记录读取的地址和当前值
current_tx->read_set[this] = std::make_shared<T>(value);
return value;
}
// 非事务场景直接返回值
return value;
}
// 写入操作，记录到写集，不立即修改实际值
void write(T new_val) {
if (current_tx && current_tx->state == TransactionState::ACTIVE) {
// 写入操作记录到写集，暂不修改实际value
current_tx->write_set[this] = std::make_shared<T>(new_val);
return;
}
// 非事务场景直接修改
value = new_val;
}
// 提交时应用写集修改
void apply_write(const T& new_val) {
value = new_val;
}
// 获取当前实际值（用于冲突检测）
T get_raw_value() const {
return value;
}
};
// 初始化线程局部变量，实际项目中需要更完善的事务管理逻辑
template <typename T>
TransactionContext* StmVariable<T>::current_tx = nullptr;
3. 事务执行与冲突检测逻辑
事务的执行流程分为三个阶段：执行事务逻辑、冲突检测、提交或回滚。冲突检测的核心是验证读集中的值是否和当前共享变量的实际值一致，如果一致说明没有冲突，可以提交，否则需要回滚重试。
// 执行事务的模板函数
template <typename Func>
auto execute_transaction(Func func, int max_retry = 3) {
for (int i = 0; i < max_retry; ++i) {
TransactionContext tx;
// 设置当前事务上下文，实际实现中需要绑定到线程局部存储
StmVariable<int>::current_tx = &tx;
try {
// 执行事务逻辑
auto result = func();
// 冲突检测：遍历读集，检查值是否被其他事务修改
bool conflict = false;
for (auto& [addr, recorded_val] : tx.read_set) {
StmVariable<int>* var = static_cast<StmVariable<int>*>(addr);
// 比较记录的值和实际值是否一致
if (*static_cast<T*>(recorded_val.get()) != var->get_raw_value()) {
conflict = true;
break;
}
}
if (conflict) {
// 有冲突，中止事务
tx.state = TransactionState::ABORTED;
continue;
}
// 无冲突，提交事务：应用写集的所有修改
for (auto& [addr, write_val] : tx.write_set) {
StmVariable<int>* var = static_cast<StmVariable<int>*>(addr);
var->apply_write(*static_cast<T*>(write_val.get()));
}
tx.state = TransactionState::COMMITTED;
StmVariable<int>::current_tx = nullptr;
return result;
} catch (...) {
// 执行异常，中止事务
tx.state = TransactionState::ABORTED;
StmVariable<int>::current_tx = nullptr;
throw;
}
}
throw std::runtime_error("事务重试次数超过上限");
}
STM使用示例
下面我们用一个并发累加的例子展示STM的使用方式，对比传统锁方案的差异：
#include <thread>
#include <vector>
// 共享变量定义
StmVariable<int> shared_counter(0);
// 事务逻辑的lambda函数
void transaction_add(int delta) {
execute_transaction([delta]() {
int current = shared_counter.read();
shared_counter.write(current + delta);
return 0;
});
}
int main() {
std::vector<std::thread> threads;
// 启动10个线程，每个线程累加1000次
for (int i = 0; i < 10; ++i) {
threads.emplace_back(transaction_add, 1000);
}
for (auto& t : threads) {
t.join();
}
// 最终输出结果应该是10000
std::cout << "最终结果：" << shared_counter.read() << std::endl;
return 0;
}
STM的适用场景与注意事项
STM并不是锁的完全替代品，它更适合读多写少、事务逻辑简单的场景：
- 优势：无需手动加锁解锁，避免死锁；代码逻辑更直观，符合串行编程思维；冲突时自动回滚重试，减少锁竞争带来的性能损耗
- 局限性：实现复杂度较高，简易实现可能有性能开销；长事务容易频繁冲突导致重试；不适合需要操作非内存资源（如文件、网络）的场景，这类操作无法回滚
实际项目中如果需要使用STM，可以参考GCC的libitm库或者Boost.STM库，这些成熟实现提供了更完善的特性和性能优化。