Me gustaría comprobar si unstd::thread ha finalizado la ejecución. Buscando stackoverflow encontré lo siguientepregunta que aborda este problema. La respuesta aceptada propone que el subproceso de trabajo establezca una variable justo antes de salir y que el subproceso principal verifique esta variable. Aquí hay un ejemplo de trabajo mínimo de tal solución:

#include <unistd.h>
#include <thread>

void work( bool* signal_finished ) {
  sleep( 5 );
  *signal_finished = true;
}

int main()
{
  bool thread_finished = false;
  std::thread worker(work, &thread_finished);

  while ( !thread_finished ) {
    // do some own work until the thread has finished ...
  }

  worker.join();
}

Alguien que hizo comentarios sobre la respuesta aceptada afirma que no se puede usar un simplebool variable como una señal, el código se rompió sin una barrera de memoria y usandostd::atomic<bool> sería correcto Mi conjetura inicial es que esto es incorrecto y simplebool Es suficiente, pero quiero asegurarme de que no me estoy perdiendo algo.¿El código anterior necesita unstd::atomic<bool> para ser correcto?

Supongamos que el subproceso principal y el trabajador se ejecutan en diferentes CPU en diferentes sockets. Lo que creo que pasaría es que el hilo principal se lee.thread_finished de la memoria caché de su CPU. Cuando el trabajador lo actualiza, el protocolo de coherencia de la memoria caché se encarga de escribir los cambios de los trabajadores en la memoria global y de invalidar la memoria caché de la CPU del subproceso principal para que tenga que leer el valor actualizado de la memoria global. ¿No es el punto de coherencia del caché para hacer que el código como el anterior funcione?