Ejemplo simple de subprocesamiento en C++
¿Alguien puede publicar un ejemplo simple de cómo iniciar dos subprocesos (orientados a objetos) en C++?
Estoy buscando objetos de subprocesos de C++ reales en los que pueda extender los métodos de ejecución (o algo similar) en lugar de llamar a una biblioteca de subprocesos de estilo C.
Dejé de lado cualquier solicitud específica del sistema operativo con la esperanza de que quien respondiera respondiera con bibliotecas multiplataforma para usar. Sólo lo estoy haciendo explícito ahora.
Cree una función que desee que ejecute el hilo, por ejemplo:
void task1(std::string msg)
{
std::cout << "task1 says: " << msg;
}
Ahora crea el threadobjeto que finalmente invocará la función anterior de esta manera:
std::thread t1(task1, "Hello");
(Es necesario #include <thread>para acceder a la std::threadclase).
El primer argumento del constructor es la función que ejecutará el hilo, seguido de los parámetros de la función. El hilo se inicia automáticamente durante la construcción.
Si más adelante desea esperar a que el hilo termine de ejecutar la función, llame a:
t1.join();
(Unirse significa que el subproceso que invocó el nuevo subproceso esperará a que el nuevo subproceso finalice su ejecución antes de continuar con su propia ejecución).
El código
#include <string>
#include <iostream>
#include <thread>
using namespace std;
// The function we want to execute on the new thread.
void task1(string msg)
{
cout << "task1 says: " << msg;
}
int main()
{
// Constructs the new thread and runs it. Does not block execution.
thread t1(task1, "Hello");
// Do other things...
// Makes the main thread wait for the new thread to finish execution, therefore blocks its own execution.
t1.join();
}
Más información sobre std::thread aquí
- En GCC, compila con
-std=c++0x -pthread. - Esto debería funcionar para cualquier sistema operativo, siempre que su compilador admita esta característica ( C++11 ).
Bueno, técnicamente cualquier objeto de este tipo terminará construyéndose sobre una biblioteca de subprocesos estilo C porque C++ acaba de especificar un std::threadmodelo estándar en C++0x , que acaba de concretarse y aún no se ha implementado.
El problema es algo sistémico. Técnicamente, el modelo de memoria C++ existente no es lo suficientemente estricto como para permitir una semántica bien definida para todos los casos de "sucede antes". Hans Boehm escribió un artículo sobre el tema hace un tiempo y jugó un papel decisivo en la elaboración del estándar C++ 0x sobre el tema.
Los subprocesos no se pueden implementar como una biblioteca
Dicho esto, existen varias bibliotecas de subprocesos C++ multiplataforma que funcionan bien en la práctica. Los bloques de construcción de subprocesos Intel contienen un objeto tbb::thread que se aproxima mucho al estándar C++ 0x y Boost tiene una biblioteca boost::thread que hace lo mismo.
Bloques de construcción de subprocesos oneAPI
Capítulo 19. Hilo (documentación de Boost)
Usando boost::thread , obtendrías algo como:
#include <boost/thread.hpp>
void task1() {
// do stuff
}
void task2() {
// do stuff
}
int main (int argc, char ** argv) {
using namespace boost;
thread thread_1 = thread(task1);
thread thread_2 = thread(task2);
// do other stuff
thread_2.join();
thread_1.join();
return 0;
}
