C++如何保证对象初始化对其他线程可见-C++-PHP中文网

C++通过内存模型和同步机制保证对象初始化对其他线程可见，核心是避免数据竞争。使用原子操作（如std::atomic配合release-acquire语义）、互斥锁（std::mutex）保护初始化过程、std::call_once确保函数仅执行一次、双重检查锁优化性能，以及静态局部变量的线程安全初始化，均可实现线程安全。happens-before关系通过程序顺序、锁、原子操作等建立，确保操作顺序和内存可见性。std::memory_order提供多种内存序选项，平衡性能与一致性。此外，RAII、线程安全容器和无锁结构也是可行方案，选择取决于具体需求。

c++如何保证对象初始化对其他线程可见

C++保证对象初始化对其他线程可见，主要依赖于内存模型和原子操作，以及避免数据竞争。简单来说，就是确保对象在被其他线程访问之前，已经完全构造完毕，并且所有写操作对其他线程可见。

解决方案：

避免数据竞争： 这是最根本的原则。如果多个线程同时读写同一块内存，且至少有一个线程是写操作，那么就存在数据竞争。解决数据竞争是保证线程安全的关键。

使用原子操作： 对于简单的类型，例如

int

登录后复制

、

bool

登录后复制

等，可以使用

std::atomic

登录后复制

来保证原子性。原子操作具有 happens-before 关系，可以保证写操作在读操作之前发生。

立即学习“C++免费学习笔记（深入）”；

#include <atomic>
#include <thread>

std::atomic<int> data(0);

void thread1() {
    data.store(42, std::memory_order_release); // 写操作，释放语义
}

void thread2() {
    int value = data.load(std::memory_order_acquire); // 读操作，获取语义
    if (value == 42) {
        // 保证 value 是 42，因为 release-acquire 关系
    }
}

int main() {
    std::thread t1(thread1);
    std::thread t2(thread2);

    t1.join();
    t2.join();

    return 0;
}

登录后复制

使用互斥锁： 对于复杂对象的初始化，可以使用

std::mutex

登录后复制

来保护共享资源。在初始化对象时，获取锁，完成初始化后释放锁。其他线程在访问对象之前，必须先获取锁，这样可以保证对象在完全初始化之后才能被访问。

#include <iostream>
#include <mutex>
#include <thread>

class MyObject {
public:
    MyObject() {
        // 模拟耗时初始化
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
        initialized = true;
        std::cout << "Object initialized by thread: " << std::this_thread::get_id() << std::endl;
    }

    bool isInitialized() const {
        return initialized;
    }

private:
    bool initialized = false;
};

std::mutex mtx;
MyObject* obj = nullptr;

void initializeObject() {
    std::lock_guard<std::mutex> lock(mtx);
    if (obj == nullptr) {
        obj = new MyObject();
    }
}

void accessObject() {
    std::lock_guard<std::mutex> lock(mtx);
    if (obj != nullptr && obj->isInitialized()) {
        std::cout << "Object accessed by thread: " << std::this_thread::get_id() << std::endl;
    } else {
        std::cout << "Object not yet initialized by thread: " << std::this_thread::get_id() << std::endl;
    }
}

int main() {
    std::thread t1(initializeObject);
    std::thread t2(accessObject);
    std::thread t3(accessObject);

    t1.join();
    t2.join();
    t3.join();

    delete obj; // 记得释放内存
    return 0;
}

登录后复制

使用

std::call_once

登录后复制

：

std::call_once

登录后复制

可以保证某个函数只被调用一次，即使在多个线程中同时调用。这对于单例模式或者只需要初始化一次的资源非常有用。

#include <iostream>
#include <mutex>
#include <thread>

class MyObject {
public:
    MyObject() {
        std::cout << "Object initialized by thread: " << std::this_thread::get_id() << std::endl;
    }
};

std::once_flag flag;
MyObject* obj = nullptr;

void initializeObject() {
    obj = new MyObject();
}

MyObject* getObject() {
    std::call_once(flag, initializeObject);
    return obj;
}

void accessObject() {
    MyObject* myObj = getObject();
    std::cout << "Object accessed by thread: " << std::this_thread::get_id() << std::endl;
}

int main() {
    std::thread t1(accessObject);
    std::thread t2(accessObject);
    std::thread t3(accessObject);

    t1.join();
    t2.join();
    t3.join();

    delete obj; // 记得释放内存
    return 0;
}

登录后复制

使用双重检查锁（Double-Checked Locking）： 这是一种优化手段，可以在某些情况下减少锁的竞争。但是需要注意，在某些编译器和平台上，双重检查锁可能存在问题，因此需要谨慎使用。通常情况下，使用

std::call_once

登录后复制

更加安全可靠。

#include <iostream>
#include <mutex>
#include <thread>
#include <atomic>

class MyObject {
public:
    MyObject() {
        std::cout << "Object initialized by thread: " << std::this_thread::get_id() << std::endl;
    }
};

std::mutex mtx;
std::atomic<MyObject*> obj(nullptr); // 使用原子指针

MyObject* getObject() {
    MyObject* tmp = obj.load(std::memory_order_acquire); // 先尝试读取
    if (tmp == nullptr) {
        std::lock_guard<std::mutex> lock(mtx);
        tmp = obj.load(std::memory_order_relaxed); // 再次读取，防止其他线程已经初始化
        if (tmp == nullptr) {
            tmp = new MyObject();
            obj.store(tmp, std::memory_order_release); // 使用原子操作存储
        }
    }
    return tmp;
}

void accessObject() {
    MyObject* myObj = getObject();
    std::cout << "Object accessed by thread: " << std::this_thread::get_id() << std::endl;
}

int main() {
    std::thread t1(accessObject);
    std::thread t2(accessObject);
    std::thread t3(accessObject);

    t1.join();
    t2.join();
    t3.join();

    delete obj.load(); // 记得释放内存
    return 0;
}

登录后复制

如何理解C++内存模型中的happens-before关系？

Happens-before 关系是 C++ 内存模型中最重要的概念之一，它定义了多线程程序中操作的顺序。如果操作 A happens-before 操作 B，那么 A 的结果对 B 可见。也就是说，A 的所有写操作都必须在 B 的读操作之前完成。理解 happens-before 关系对于编写正确的并发程序至关重要。

Happens-before 关系可以由以下几种方式建立：

程序顺序： 在单个线程中，代码的执行顺序就是 happens-before 关系。
互斥锁： 如果线程 A 释放了互斥锁，线程 B 获取了同一个互斥锁，那么线程 A 释放锁的操作 happens-before 线程 B 获取锁的操作。
原子操作： 使用
```
std::memory_order_release
```
登录后复制
存储数据的线程 happens-before 使用
```
std::memory_order_acquire
```
登录后复制
读取数据的线程。
线程创建： 创建线程的操作 happens-before 新线程的起始函数开始执行。
线程join： 线程的起始函数执行完成 happens-before join该线程的线程继续执行。

正确使用 happens-before 关系可以避免数据竞争，保证程序的正确性。

协和·太初

国内首个针对罕见病领域的AI大模型

查看详情

std::memory_order

登录后复制

的几种类型及其含义？

std::memory_order

登录后复制

用于指定原子操作的内存顺序，它决定了原子操作如何与其他内存操作进行同步。C++ 提供了以下几种

std::memory_order

登录后复制

类型：

std::memory_order_relaxed
登录后复制
：这是最宽松的内存顺序。只保证原子操作的原子性，不保证与其他线程的同步。
std::memory_order_consume
登录后复制
：用于读取操作。如果线程 A 存储了一个值，线程 B 使用
```
std::memory_order_consume
```
登录后复制
读取了这个值，那么线程 A 存储操作 happens-before 线程 B 读取操作。但是，
```
std::memory_order_consume
```
登录后复制
的使用场景比较复杂，通常不建议使用。
std::memory_order_acquire
登录后复制
：用于读取操作。线程 A 存储了一个值，线程 B 使用
```
std::memory_order_acquire
```
登录后复制
读取了这个值，那么线程 A 存储操作 happens-before 线程 B 读取操作。
std::memory_order_release
登录后复制
：用于存储操作。线程 A 使用
```
std::memory_order_release
```
登录后复制
存储了一个值，线程 B 使用
```
std::memory_order_acquire
```
登录后复制
读取了这个值，那么线程 A 存储操作 happens-before 线程 B 读取操作。
std::memory_order_acq_rel
登录后复制
：用于同时进行读取和存储操作。相当于同时具有
```
std::memory_order_acquire
```
登录后复制
和
```
std::memory_order_release
```
登录后复制
的语义。
std::memory_order_seq_cst
登录后复制
：这是最强的内存顺序。保证所有原子操作都按照全局一致的顺序执行。如果没有指定内存顺序，默认使用
```
std::memory_order_seq_cst
```
登录后复制
。

选择合适的内存顺序可以提高程序的性能，同时保证程序的正确性。通常情况下，使用

std::memory_order_release

登录后复制

和

std::memory_order_acquire

登录后复制

就可以满足大部分需求。

除了上述方法，还有没有其他C++中保证对象初始化线程安全的方式？

除了前面提到的原子操作、互斥锁、

std::call_once

登录后复制

和双重检查锁，还有一些其他的方法可以在 C++ 中保证对象初始化的线程安全：

静态局部变量： C++ 标准保证静态局部变量的初始化是线程安全的。这意味着，如果一个静态局部变量在多个线程中同时被初始化，C++ 运行时会保证只有一个线程会执行初始化操作，其他线程会等待初始化完成。

#include <iostream>
#include <thread>

class MyObject {
public:
    MyObject() {
        std::cout << "Object initialized by thread: " << std::this_thread::get_id() << std::endl;
    }
};

MyObject& getObject() {
    static MyObject obj; // 静态局部变量，线程安全初始化
    return obj;
}

void accessObject() {
    MyObject& myObj = getObject();
    std::cout << "Object accessed by thread: " << std::this_thread::get_id() << std::endl;
}

int main() {
    std::thread t1(accessObject);
    std::thread t2(accessObject);
    std::thread t3(accessObject);

    t1.join();
    t2.join();
    t3.join();

    return 0;
}

登录后复制

使用构造函数进行初始化： 确保对象的所有成员变量都在构造函数中初始化，可以避免未初始化的数据被其他线程访问。如果构造函数本身是线程安全的，那么对象的初始化也是线程安全的。
使用线程安全的容器： 如果对象存储在线程安全的容器中，例如
```
std::atomic
```
登录后复制
或者使用互斥锁保护的容器，那么对象的初始化也是线程安全的。
使用 RAII（Resource Acquisition Is Initialization）： RAII 是一种 C++ 编程技术，它利用对象的生命周期来管理资源。通过在构造函数中获取资源，在析构函数中释放资源，可以保证资源在使用完毕后总是会被释放，即使在发生异常的情况下也是如此。RAII 可以用于保证对象的初始化和销毁都是线程安全的。
使用无锁数据结构： 对于某些特定的场景，可以使用无锁数据结构来避免锁的竞争。无锁数据结构使用原子操作来实现线程安全，可以提高程序的性能。但是，无锁数据结构的实现比较复杂，需要仔细考虑内存顺序和数据竞争的问题。