c++11 shared object store/load synchronization - multithreading

Question

I have a shared object of type:
struct A {
int x;
int y;
int z;
};
A obj;
There is 2 threads running in parallel.
Thread #1 modifies object's members:
// .. some code before
obj.x = 42;
obj.y = 42;
obj.z = 42;
// .. now thread #2 can read obj
Thread #2 reads object's members:
// .. some code before
int x = obj.x;
int y = obj.y;
int z = obj.z;
// .. some code after
How to synchronize the flow most efficiently that the thread #2 reads object's members only after thread #1 modified them all?

Answer 1

Use std::atomic here.
boost::atomic<int> x { INT_MAX };
// thread1:
while (x.load(memory_order_acquire) == INT_MAX);
// thread2:
x.store(42,memory_order_release);
EDIT add runnable example
main.cpp
#include <iostream>
#include <chrono>
#include <thread>
#include <atomic>
struct Foo {
Foo(): x_(0) {}
std::atomic<int> x_;
};
using namespace std;
int main() {
Foo foo;
thread th1(
[&]() {
cout << "thread1 Waiting for thread2 setting value for x" << endl;
while (foo.x_.load(memory_order_acquire) == 0);
int current = foo.x_.load(memory_order_acquire);
cout << "thread 1 print current value of x is " << current << endl;
});
thread th2(
[&]() {
std::chrono::milliseconds dura( 2000 );
std::this_thread::sleep_for( dura );
cout << "thread2 set up value for x" << endl;
foo.x_.store(42,memory_order_release);
});
th1.join();
th2.join();
return 0;
}
CMakeLists.txt
cmake_minimum_required(VERSION 2.8.4)
project(atomicExample)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -stdlib=libc++ -std=c++11")
set(SOURCE_FILES main.cpp)
add_executable(atomicExample ${SOURCE_FILES})

Answer 2

You can use std::mutex to synchronize critical sections of your code. std::lock_guard locks a mutex and releases it when the lock_guard goes out of scope. I've also added a condition variable to ensure that thread2() waits for thread1() to finish assigning values to obj before continuing.
Example:
#include <mutex>
#include <condition_variable>
struct A {
int x;
int y;
int z;
};
A obj;
std::mutex m;
std::condition_variable cv;
bool thread1Done = false;
void thread1()
{
std::lock_guard<std::mutex> lock( m );
obj.x = 42;
obj.y = 42;
obj.z = 42;
thread1Done = true;
cv.notifyAll();
}
void thread2()
{
std::unique_lock<std::mutex> lock( m );
while ( !thread1Done ) {
cv.wait( lock );
}
int x = obj.x;
int y = obj.y;
int z = obj.z;
}