C++11并发编程与内存模型实战解析

长沮

1. C++11并发编程革命

作为C++程序员，我们曾经不得不在不同平台上使用pthread或Windows API来实现多线程，这种平台依赖让代码难以维护。C++11带来的并发支持彻底改变了这一局面，我第一次在实际项目中使用这些特性时，深刻感受到了标准化带来的便利。

1.1 内存模型：多线程编程的基石

C++11内存模型定义了多线程环境下对共享数据访问的基本规则。记得我刚接触时，对"顺序一致性"这个概念困惑了很久。简单来说，它保证了：

原子操作（atomic operations）不会被线程调度打断
正确同步的操作具有确定的执行顺序
修改后的值对其他线程立即可见

这三个特性分别对应原子性、有序性和可见性。在实际项目中，我们最常使用的是std::atomic模板类：

cpp复制std::atomic<int> counter(0);

void increment() {
    for(int i=0; i<1000; ++i) {
        counter.fetch_add(1, std::memory_order_relaxed);
    }
}

注意：memory_order参数的选择很关键。relaxed序只保证原子性，acquire/release序保证特定顺序，seq_cst（默认）则提供最强的顺序保证。在x86架构上，seq_cst的开销其实很小，但在ARM等弱内存模型架构上差异明显。

1.2 线程与锁：类型安全的并发原语

C++11的线程库比平台原生API更安全易用。记得我第一次用std::thread替换pthread代码时，代码量减少了近40%。关键组件包括：

std::thread：封装了系统线程
std::mutex：互斥锁（支持RAII风格的std::lock_guard）
std::condition_variable：线程间通信

典型的生产者-消费者模式实现：

cpp复制std::queue<int> data_queue;
std::mutex mtx;
std::condition_variable cv;

void producer() {
    for(int i=0; i<10; ++i) {
        std::lock_guard<std::mutex> lk(mtx);
        data_queue.push(i);
        cv.notify_one();
    }
}

void consumer() {
    while(true) {
        std::unique_lock<std::mutex> lk(mtx);
        cv.wait(lk, []{return !data_queue.empty();});
        int val = data_queue.front();
        data_queue.pop();
        lk.unlock();
        process(val);
    }
}

经验：优先使用RAII风格的锁管理（lock_guard/unique_lock），避免手动lock/unlock。unique_lock比lock_guard更灵活，支持延迟锁定和所有权转移。

1.3 异步编程利器：future/promise模型

future/promise模型是我处理异步任务的首选方案。它比直接使用线程更高级，也比回调更清晰。典型的应用场景：

cpp复制std::future<int> async_task() {
    std::promise<int> p;
    auto f = p.get_future();
    
    std::thread([&p]{
        try {
            int result = compute_something();
            p.set_value(result);
        } catch(...) {
            p.set_exception(std::current_exception());
        }
    }).detach();
    
    return f;
}

更简单的方式是使用std::async：

cpp复制auto future = std::async(std::launch::async, []{
    return compute_something();
});
int result = future.get();

避坑指南：std::async的启动策略（launch::async或launch::deferred）会影响任务执行时机。明确指定策略可以避免不确定行为。

2. 语法糖与类型推导

2.1 auto与decltype：让编译器为你工作

auto和decltype是我日常编码中使用最频繁的特性之一。它们不仅能减少打字量，更重要的是能让代码更健壮。

auto的典型用法：

cpp复制std::vector<std::map<std::string, std::complex<double>>> nested_container;
// 不用auto
std::vector<std::map<std::string, std::complex<double>>>::iterator it = nested_container.begin();
// 使用auto
auto it = nested_container.begin();

decltype的实用场景：

cpp复制template<typename T, typename U>
auto add(T t, U u) -> decltype(t + u) {
    return t + u;
}

类型推导陷阱：auto会忽略引用和const限定符，decltype则会保留。使用decltype(auto)可以精确推导表达式类型。

2.2 范围for循环：告别繁琐的迭代器

范围for循环让容器遍历变得异常简单：

cpp复制std::vector<int> vec = {1,2,3,4,5};
// 传统方式
for(std::vector<int>::iterator it=vec.begin(); it!=vec.end(); ++it) {
    process(*it);
}
// 范围for
for(auto& elem : vec) {
    process(elem);
}

性能提示：对于大型容器，使用auto&避免不必要的拷贝；需要修改元素时用auto&，只读访问用const auto&。

3. 智能指针：告别手动内存管理

3.1 unique_ptr：独占所有权的轻量级选择

unique_ptr是资源管理的首选工具，它没有额外开销，却能保证资源释放：

cpp复制void process_file() {
    std::unique_ptr<FILE, decltype(&fclose)> file(fopen("data.txt", "r"), &fclose);
    if(!file) throw std::runtime_error("Open failed");
    // 使用文件...
} // 自动调用fclose

转移所有权：unique_ptr不可拷贝但可移动，使用std::move转移所有权。

3.2 shared_ptr/weak_ptr：共享所有权与循环引用解决方案

shared_ptr通过引用计数实现共享所有权：

cpp复制class Node {
    std::vector<std::shared_ptr<Node>> children;
    std::weak_ptr<Node> parent; // 避免循环引用
public:
    void set_parent(std::shared_ptr<Node> p) {
        parent = p;
        p->children.push_back(shared_from_this());
    }
};

性能考虑：shared_ptr有原子引用计数的开销，仅当确实需要共享所有权时才使用。make_shared比直接new更高效，因为它将控制块和对象分配在连续内存中。

4. 其他实用特性

4.1 统一初始化：一致的初始化语法

统一初始化解决了C++初始化语法混乱的问题：

cpp复制struct Point {
    int x, y;
};

// 各种初始化方式
Point p1 = {1,2};    // C风格
Point p2(1,2);       // 构造函数
Point p3{1,2};       // 统一初始化
int arr[] = {1,2,3}; // 数组初始化

窄化转换检查：列表初始化会检查窄化转换，如int x{1.2}会导致编译错误，而int x(1.2)不会。

4.2 nullptr：类型安全的空指针

nullptr解决了NULL的二义性问题：

cpp复制void foo(int);
void foo(char*);

foo(NULL);    // 调用foo(int)，可能不是预期行为
foo(nullptr); // 明确调用foo(char*)

4.3 constexpr：编译期计算

constexpr将计算移到编译期：

cpp复制constexpr int factorial(int n) {
    return n <= 1 ? 1 : n * factorial(n-1);
}

int main() {
    constexpr int fact5 = factorial(5); // 编译期计算
    std::array<int, factorial(3)> arr;  // 数组大小在编译期确定
}