int some_global_variable; // Нет volatile

// ...

std::cout << some_global_variable << std::endl; // (1) -- Вот тут переменная попадает в регистр
mutex.lock(); // Да, лучше RAII, но речь сейчас не об этом
std::cout << some_global_variable << std::endl; // (2) -- Не обязан перечитать из памяти, даже несмотря на выполнение инструкции MFENCE?
mutex.unlock();

FH>int some_global_variable; // Нет volatile

FH>// ...

FH>std::cout << some_global_variable << std::endl; // (1) -- Вот тут переменная попадает в регистр
FH>mutex.lock(); // Да, лучше RAII, но речь сейчас не об этом
FH>std::cout << some_global_variable << std::endl; // (2) -- Не обязан перечитать из памяти, даже несмотря на выполнение инструкции MFENCE?
FH>mutex.unlock();
FH>

The library defines a number of atomic operations (Clause 29) and operations on mutexes (Clause 30)
that are specially identified as synchronization operations. These operations play a special role in making
assignments in one thread visible to another.

Note: For example, a call that acquires a mutex will perform an acquire operation
on the locations comprising the mutex. Correspondingly, a call that releases the same mutex will perform a
release operation on those same locations. Informally, performing a release operation on A forces prior side
effects on other memory locations to become visible to other threads that later perform a consume or an
acquire operation on A.

prior side
effects on other memory locations to become visible

int x;
std::mutex m;
std::atomic<bool> run_thread;

void thread_fn() {
  while (!run_thread) /* busy-wait */;

  m.lock();
  x = 2;
  m.unlock();
}

int main() {
  std::thread t(thread_fn);
  x = 1;
  run_thread = true; // это синхронизирующая операция (release), именно одна заставляет "x" перечитываться

  m.lock();
  std::cout << x;
  m.unlock();

  t.join();
}

int main() {
  std::thread t(thread_fn);
  run_thread = true;
  x = 1; // гонка c операцией "x = 2" в thread_fn

  run_thread = true;
  x = 1;
  std::thread t(thread_fn); // теперь само создание потока - синхронизирующая операция

volatile int x;
x = 1;
// в "y" может сразу записаться 1, без перечитывания "x"
// потому что между этими строчками ничего нет, а значит нету наблюдателя, который может заметить что перечитывания не произошло
int y = x;

FH>int some_global_variable; // Нет volatile

FH>// ...

FH>std::cout << some_global_variable << std::endl; // (1) -- Вот тут переменная попадает в регистр
FH>mutex.lock(); // Да, лучше RAII, но речь сейчас не об этом
FH>std::cout << some_global_variable << std::endl; // (2) -- Не обязан перечитать из памяти, даже несмотря на выполнение инструкции MFENCE?
FH>mutex.unlock();
FH>

//thread 2
mutex.lock();
some_global_variable = 777;
mutex.unlock();