threads - thread library c++
Esperando múltiples futuros? (2)
El soporte de subprocesos en C ++ 11 fue solo una primera pasada, y mientras std::future rocks, no admite múltiples esperas todavía.
Sin embargo, puedes fingir de manera relativamente ineficiente. Termina creando un hilo de ayuda para cada std::future (ouch, muy caro), luego juntando su "este future está listo" en una cola de mensajes de un solo consumidor sincronizada de muchos productores, luego configurando una tarea de consumidor que distribuye el hecho de que un determinado std::future está listo.
El std::future en este sistema no agrega mucha funcionalidad, y tener tareas que indiquen directamente que están listas y que coloque su resultado en la cola anterior sería más eficiente. Si sigue esta ruta, puede escribir wrapper que coincida con el patrón de std::async o std::thread , y devolver un objeto similar std::future que represente un mensaje de cola. Esto básicamente implica volver a implementar un fragmento de la biblioteca de concurrencia.
Si desea permanecer con std::future , puede crear shared_future s, y hacer que cada tarea dependiente dependa del conjunto de shared_future s: es decir, hacerlo sin un planificador central. Esto no permite cosas como mensajes de aborto / apagado, que considero esenciales para un sistema robusto de tareas múltiples.
Finalmente, puede esperar C++2x , o siempre que la concurrencia TS esté plegada en el estándar, para resolver el problema por usted.
Me gustaría ejecutar tareas (hilos de trabajo) del mismo tipo, pero no más de un cierto número de tareas a la vez. Cuando una tarea finaliza, su resultado es una entrada para una nueva tarea que, luego, puede iniciarse.
¿Hay alguna forma de implementar esto con el paradigma async / future en C ++ 11?
A primera vista, parece sencillo, solo genera múltiples tareas con:
std::future<T> result = std::async(...);
y, luego, ejecute result.get() para obtener un resultado asíncrono de una tarea.
Sin embargo, el problema aquí es que los objetos futuros deben almacenarse en una especie de cola y esperar uno por uno. Sin embargo, es posible iterar sobre los objetos futuros una y otra vez comprobando si alguno de ellos está listo, pero no es deseable debido a una carga de CPU innecesaria.
¿Es posible de alguna manera esperar que un futuro de un conjunto determinado esté listo y obtenga su resultado?
La única opción que puedo pensar hasta ahora es un enfoque de la vieja escuela sin asincronía / futuro. Específicamente, al generar múltiples subprocesos de trabajo y al final de cada subproceso, se envía su resultado a una cola protegida por mutex que notifica al subproceso de espera a través de una variable de condición que la cola se ha actualizado con más resultados.
¿Hay alguna otra mejor solución con async / future posible?
Podrías crear todos los futuros de la " generación 1 " y darles todos esos futuros a las tareas de tu generación 2 , que luego esperarán su propia contribución.