这种std :: atomic_thread_fence的使用是否正确？

Question

I want to initialize a field in a constructor and never change it afterwards. I want the guarantee that after the constructor finished, every read of the field reads the initialized value, no matter in which thread the read happens.

Basically, I want the same guarantees as a final field gives in Java.

This is what I tried:

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

struct Foo
{
    Foo(int x) : x(x)
    {
        // ensure all writes are visible to other threads
        std::atomic_thread_fence(std::memory_order_release);
    }

    int x;
};

void print_x(Foo const& foo)
{
    // I don't think I need an aquire fence here, because the object is
    // newly constructed, so there cannot be any stale reads.
    std::cout << foo.x << std::endl;
}

int main()
{
    Foo foo(1);
    std::thread t(print_x, foo);
    t.join();
}

• Is this guaranteed to always print 1 or can thread t observe foo.x in an uninitialized state?
• What if instead of using the member initializer x(x) an explicit assignment this->x = x; is used?
• What if x is not an int but some class type?
• Does making x a const int change anything with regards to thread safety?

Answer 1

Basically, if everything else is correct, there shouldn't be any problem. After initializing the field, and before accessing it in any thread, you need some sort of memory synchronization; that's clear. Otherwise, how can the other threads know that it is constructed. If you initialize it before starting the other threads, then creating the threads will ensure the necessary synchronization. (This only holds between the thread doing the creation, and the created thread. Other already running threads are not synchronization.) After that, as long as no thread modifies the value, no synchronization is needed.

With regards to your code, you don't need the fence, because the value is initialized before any of the other threads are created, and creating the thread ensures the necessary synchronization.