c++ - pthread - semaforos posix ejemplos

La notificación variable de condición c++ no funciona como se esperaba

Question

Estoy intentando lanzar nuevos hilos tan pronto como haya comenzado el trabajo en el anterior worker_thread , pero tal vez haya terminado o no. He reemplazado el trabajo iniciado y terminado con retrasos de tiempo. Mi código es:

#include <iostream>
#include <string>
#include <mutex>
#include <condition_variable>
#include <future>
#include <atomic>
#include <chrono>
#include <thread>
std::mutex m;
std::condition_variable cv;
bool started = false;
void worker_thread()
{
std::unique_lock<std::mutex> lk(m);
static std::atomic<int> count(1);
std::this_thread::sleep_for(std::chrono::milliseconds{(count % 5) * 100});
std::cerr << "Start Worker thread: " << count << "/n";
started = true;
lk.unlock();
cv.notify_one();
std::this_thread::sleep_for(std::chrono::milliseconds{3000});
std::cerr << "Exit Worker thread: " << count << "/n";
++count;
}
int main()
{
while(1) {
std::async(std::launch::async, worker_thread);
std::unique_lock<std::mutex> lk(m);
cv.wait(lk, []{return started;});
started = false;
}
}

El resultado es así:

Start Worker thread: 1
Exit Worker thread: 1
Start Worker thread: 2
Exit Worker thread: 2
Start Worker thread: 3
Exit Worker thread: 3
Start Worker thread: 4
Exit Worker thread: 4
Start Worker thread: 5
Exit Worker thread: 5

que no es el comportamiento que yo quería Lo que quería era algo así como (no exactamente) esto:

Start Worker thread: 1
Start Worker thread: 2
Start Worker thread: 3
Start Worker thread: 4
Exit Worker thread: 1
Exit Worker thread: 3
Exit Worker thread: 4
Exit Worker thread: 2
Start Worker thread: 5
Exit Worker thread: 5

Actualmente, el siguiente subproceso solo se inicia cuando el trabajo finaliza en el hilo anterior. Pero quiero iniciar el siguiente subproceso tan pronto como se inicie el trabajo en el hilo anterior y no esperar a que termine, solo esperar el inicio.

Answer 1

std::async devuelve un std::future resultado de mantenimiento std::future de la ejecución de la función. En tu caso, es un objeto temporal que se destruye inmediatamente. La documentación para std::future dice:

estas acciones no se bloquearán para que el estado compartido esté listo, excepto que puede bloquear si todo lo siguiente es verdadero :

✔ el estado compartido fue creado por una llamada a std :: async

✔ el estado compartido aún no está listo

✔ esta fue la última referencia al estado compartido

Todos estos son verdaderos, por lo que la destrucción de ese future se bloqueará hasta que la función del trabajador termine de ejecutarse.

Puede crear un hilo separado para evitar este problema:

std::thread(worker_thread).detach();