Multithreading en C++ es una característica que permite realizar múltiples tareas simultáneamente. Un hilo es la unidad de trabajo de un proceso particular que se está ejecutando. Numerosos subprocesos se ejecutan de forma independiente entre sí al mismo tiempo para realizar subprocesos múltiples.
Cómo implementar subprocesos múltiples en C++
Un programa multihilo tiene dos o más partes que tienden a ejecutarse simultáneamente, cada parte se conoce como hilo y tiene una ruta diferente de ejecución. Numerosos subprocesos se ejecutan de forma independiente entre sí al mismo tiempo para realizar subprocesos múltiples.
Requisitos previos para subprocesos múltiples en C++
En Windows, las funciones relacionadas con subprocesos se pueden realizar en C++ 11 y versiones avanzadas. Cuando se utiliza el compilador Dev-C++, de forma predeterminada está en la versión C++ 3, por lo que es necesario cambiarlo manualmente a la versión C++ 11. El entorno GNU C++11 se puede seleccionar cambiando la configuración estándar del idioma.
Abra el compilador Dev-C++ y vaya a 'Herramientas' en la barra de tareas. Seleccione 'Opciones del compilador' y luego seleccione 'Configuración', haga clic en el bloque 'Generación de código' y aparecerá una lista de los comandos. Seleccione GNU C++11 en “Language Standard(-std)” y luego haga clic en Aceptar. Ahora este compilador está listo para soportar operaciones de subprocesos.
Descarga las bibliotecas desde GitHub y colóquelos en la carpeta lib del compilador Cpp. Llame a estas bibliotecas en el programa usando #include “mingw.thread.h” y los archivos de encabezado
std::thread thread_object ( invocable ) ;
El std::thread es compatible con el archivo de encabezado #include “mingw.thread.h” en C++11. Es una clase de subproceso y representa un único subproceso. Se crea un nuevo hilo usando std::thread y se le pasa un invocable. Callable es un código ejecutable que se ejecuta cuando se ejecuta el hilo. Invocable puede ser cualquiera de los tres tipos que se detallan a continuación:
Cuando se crea un objeto, lanza un nuevo hilo que ejecuta el código en el invocable.
Lanzamiento de hilo usando objeto de función
Un objeto de función se puede utilizar como invocable para iniciar el hilo, el operador de sobrecarga () lo hace invocable:
clase función_objeto_clase {operador nulo ( ) ( parámetros )
{
Declaraciones;
}
}
std::thread thread_object ( clase_objeto_función ( ) , parámetros )
La función de sobrecarga se proporciona al constructor como primer objeto y a las declaraciones como segundo objeto.
Lanzamiento de hilo usando puntero de función
Se define un puntero de función y luego se utiliza como invocable para iniciar un hilo:
llamada_función vacía ( parámetro ){
Declaraciones;
}
std::hilo thread_obj ( llamada_función, parámetros ) ;
Los argumentos a pasar se escriben después del nombre de la función.
Lanzamiento de Thread usando Lambda Expression
El objeto de hilo se puede iniciar usando lambda como invocable.
// Definir una expresión lambdaauto f = [ ] ( parámetros )
{
Declaraciones;
} ;
std::thread thread_object ( f, parámetros ) ;
Se define la expresión lambda y en ella se llaman los parámetros para iniciar el hilo.
En algunos casos, el hilo debe detenerse antes de comenzar a ejecutar el siguiente comando. El std::hilo::unirse () La función se utiliza para esperar a que finalice el hilo. Por ejemplo, en caso de que asignemos una tarea de GUI al hilo, primero debemos esperar a que finalice para cargar correctamente la GUI y luego se ejecutará el siguiente comando.
ent principal ( ){
std::hilo t1 ( invocable ) ;
t1.unirse ( ) ;
Declaraciones;
}
Ejemplo
Este es un programa que se ejecuta para realizar subprocesos múltiples utilizando los tres invocables. Tres invocables diferentes ejecutan sus respectivos comandos simultáneamente tres veces sin ser interrumpidos entre sí:
#incluir#incluir
usando el espacio de nombres estándar;
vacío foo ( entero Z )
{
para ( int yo = 0 ; i < Z; yo ++ ) {
corte << 'Función de uso de hilo'
'puntero como invocable \norte ' ;
}
}
clase thread_obj {
público:
operador nulo ( ) ( entero x )
{
para ( int yo = 0 ; i < X; yo ++ )
corte << 'Función de uso de hilo'
'objeto como invocable \norte ' ;
}
} ;
// código principal
ent principal ( )
{
corte << 'Hilos 1 y 2 y 3 '
'operando independientemente'
<< fin;
hilo th1 ( foo, 3 ) ;
hilo th2 ( objeto_hilo ( ) , 3 ) ;
auto f = [ ] ( entero x ) {
para ( int yo = 0 ; i < X; yo ++ )
corte << 'Hilo usando lambda'
'expresión como invocable \norte ' ;
} ;
hilo th3 ( F, 3 ) ;
th1.unirse ( ) ;
th2.unirse ( ) ;
th3.unirse ( ) ;
devolver 0 ;
}
En este programa, los tres invocables, incluidos el puntero de función, el objeto de función y la expresión lambda, se utilizan para iniciar los tres subprocesos al mismo tiempo. Los subprocesos 1, 2 y 3 imprimen sus valores al mismo tiempo, independientemente uno del otro, sin ser interrumpidos entre sí. Imprimen sus valores tres veces. La función join() se utiliza para esperar a que finalice el hilo.
Las salidas de los tres subprocesos se muestran de forma independiente y se repiten tres veces. Cada hilo espera a que el otro termine primero.
Conclusión
Multithreading en C++ es una característica que permite realizar múltiples tareas simultáneamente. El programa multihilo tiene dos o más secciones que pueden ejecutarse simultáneamente, cada parte se conoce como hilo y tiene una ruta de ejecución separada. Hay tres invocables para iniciar subprocesos, punteros de función, objetos de función y expresiones lambda. Estos permiten el subproceso múltiple.