Crea un grupo de hilos en C ++

Un grupo de subprocesos es un conjunto de hilos donde cada hilo tiene una especie de tarea que realizar. Entonces, diferentes hilos llevan a cabo diferentes tipos de tareas. Entonces, cada hilo tiene su especialización de tareas. Una tarea es básicamente una función. Funciones similares se realizan mediante un hilo en particular; Otro hilo realiza un conjunto similar de funciones similares, y así sucesivamente. Aunque un hilo ejecutivo ejecuta una función de nivel superior, un hilo por definición es la instanciación de un objeto desde la clase de subproceso. Diferentes hilos tienen argumentos diferentes, por lo que un hilo en particular debe atender un conjunto similar de funciones.

En C ++, este grupo de hilos debe administrarse. C ++ no tiene una biblioteca para crear un grupo de subprocesos y la gestión es. Esto probablemente se deba a que hay diferentes formas de crear un grupo de hilos. Entonces, un programador C ++ tiene que crear un grupo de hilos basado en las necesidades.

Que es un hilo? Un hilo es un objeto instanciado de la clase de hilo. En la instanciación normal, el primer argumento del constructor de hilos es el nombre de una función de nivel superior. El resto de los argumentos al constructor de subprocesos son argumentos para la función. Como el hilo está instanciado, la función comienza a ejecutar. La función C ++ Main () es una función de nivel superior. Otras funciones en ese alcance global son funciones de alto nivel. Sucede que la función principal () es un hilo que no necesita una declaración formal como lo hacen otros hilos. Considere el siguiente programa:

#incluir
#incluir
usando el espacio de nombres STD;
vacío func ()
cout << "code for first output" << endl;
cout << "code for second output" << endl;

int main ()

hilo thr (func);
thr.unirse();
/ * Otras declaraciones */
regresar 0;

La salida es:

Código para la primera salida
Código para la segunda salida

Tenga en cuenta la inclusión de la biblioteca de subprocesos que tiene la clase de hilo. func () es una función de nivel superior. La primera declaración en la función main () la usa en la instancia del hilo, thr. La siguiente declaración en Main (), es una declaración de unión. Se une al hilo THR al cuerpo del hilo de función principal (), en la posición en la que está codificada. Si esta declaración está ausente, la función principal puede ejecutarse hasta la finalización sin que la función de subproceso se complete. Eso significa problemas.

Un comando similar al siguiente, debe usarse para ejecutar un programa C ++ 20 de subprocesos, para el compilador G ++:

g ++ -std = C ++ 2a temperatura.CPP -LPTHREAD -O TEMP

Este artículo explica una forma de crear y administrar un grupo de hilos en c++.

Contenido del artículo

• Requisitos de ejemplo de grupo de hilos
• Variables globales
• La función de hilo maestro
• función principal
• Conclusión

Requisitos de ejemplo de grupo de hilos

Los requisitos para este grupo ilustrativo de hilos son simples: hay tres hilos y un hilo maestro. Los hilos están subordinados al hilo maestro. Cada hilo subordinado funciona con una estructura de datos de cola. Entonces hay tres colas: qu1, qu2 y qu3. La biblioteca de cola, así como la biblioteca de hilos, deben incluirse en el programa.

Cada cola puede tener más de una llamada de función pero de la misma función de nivel superior. Es decir, cada elemento de una cola es para una llamada de función de una función de nivel superior particular. Entonces, hay tres funciones diferentes de nivel superior: una función de nivel superior por hilo. Los nombres de las funciones son FN1, FN2 y FN3.

La función exige cada cola difiere solo en sus argumentos. Para simplicidad y para este programa del programa, las llamadas de funciones no tendrán argumento. De hecho, el valor de cada cola en este ejemplo será el mismo entero: 1 que el valor para todos los elementos QU1; 2 como el valor para todos los elementos QU2; y 3 como el valor de todos los elementos de Qu3.

Una cola es una estructura First_in-First_out. Entonces, la primera llamada (número) para ingresar a una cola es la primera en irse. Cuando una llamada (número) sale, la función correspondiente y su hilo se ejecutan.

La función Main () es responsable de alimentar cada una de las tres colas, con llamadas para las funciones apropiadas, por lo tanto, los hilos apropiados.

El hilo maestro es responsable de verificar si hay una llamada en alguna cola, y si hay una llamada, llama a la función apropiada a través de su hilo. En este ejemplo del programa, cuando ninguna cola tiene ningún hilo, el programa finaliza.

Las funciones de nivel superior son simples, para este ejemplo pedagógico, son:

vacío fn1 ()
cout << "fn1" << endl;

void fn2 ()
cout << "fn2" << endl;

vacío fn3 ()
cout << "fn3" << endl;

Los hilos correspondientes serán Thr1, Thr2 y Thr3. El hilo maestro tiene su propia función maestra. Aquí, cada función tiene solo una declaración. La salida de la función fn1 () es "fn1". La salida de la función fn2 () es "fn2". La salida de la función fn3 () es "fn3".

Al final de este artículo, el lector puede reunir todos los segmentos de código en este artículo para formar un programa de grupo de subprocesos.

Variables globales

La parte superior del programa con las variables globales es:

#incluir
#incluir
#incluir
usando el espacio de nombres STD;
cola qu1;
cola qu2;
cola qu3;
hilo thr1;
hilo Thr2;
hilo thr3;

Las variables de cola y hilo son variables globales. Han sido declarados sin inicialización ni declaración. Después de esto, en el programa, deberían ser las tres funciones subordinadas de nivel superior, como se muestra arriba.

La biblioteca iostream se incluye para el objeto Cout. La biblioteca de hilos está incluida para los hilos. Los nombres de los hilos son Thr1, Thr2 y Thr3. La biblioteca de la cola está incluida para las colas. Los nombres de las colas son qu1, qu2 y qu3. Qu1 corresponde a Thr1; qu2 corresponde a thr2, y qu3 corresponde a thr3. Una cola es como un vector, pero es para FIFO (First_in-First_out).

La función de hilo maestro

Después de las tres funciones subordinadas de nivel superior, son la función maestra en el programa. Es:

void masterfn ()
trabajar:
if (qu1.size ()> 0) thr1 = hilo (fn1);
if (qu2.size ()> 0) thr2 = hilo (fn2);
if (qu3.size ()> 0) thr3 = hilo (fn3);
if (qu1.size ()> 0)
qu1.estallido();
thr1.unirse();

if (qu2.size ()> 0)
qu2.estallido();
thr2.unirse();

if (qu3.size ()> 0)
qu3.estallido();
thr3.unirse();

if (qu1.size () == 0 && qu1.size () == 0 && qu1.size () == 0)
devolver;
ir al trabajo;

El bucle goto incorpora todo el código de la función. Cuando todas las colas están vacías, la función devuelve nula, con la declaración, "return";.

El primer segmento de código en el bucle de goto tiene tres declaraciones: una para cada cola y el hilo correspondiente. Aquí, si una cola no está vacía, se ejecuta su hilo (y la función subordinada de nivel superior).

El siguiente segmento de código consta de tres construcciones IF, cada una correspondiente a un hilo subordinado. Cada construcción if tiene dos declaraciones. La primera declaración elimina el número (para la llamada), que podría haber tenido lugar en el primer segmento de código. La siguiente es una declaración de unión, lo que asegura que el hilo correspondiente funcione hasta la finalización.

La última declaración en el bucle de goto termina la función, saliendo del bucle si todas las colas están vacías.

Función principal

Después de la función de hilo maestro en el programa, debe ser la función principal (), cuyo contenido es:

qu1.empuje (1);
qu1.empuje (1);
qu1.empuje (1);
qu2.empuje (2);
qu2.empuje (2);
qu3.empuje (3);
Thread Masterthr (masterfn);
cout << "Program has started:" << endl;
maestro.unirse();
cout << "Program has ended." << endl;

La función main () es responsable de poner números que representan llamadas a las colas. Qu1 tiene tres valores de 1; Qu2 tiene dos valores de 2, y Qu3 tiene un valor de 3. La función principal () inicia el hilo maestro y se une a su cuerpo. Una salida de la computadora del autor es:

El programa ha comenzado:
fn2
FN3
fn1
fn1
fn2
fn1
El programa ha terminado.

La salida muestra las operaciones concurrentes irregulares de los subprocesos. Antes de que la función Main () se una a su hilo maestro, muestra "el programa ha comenzado:". El hilo maestro llama a Thr1 para fn1 (), Thr2 para fn2 () y thr3 para fn3 (), en ese orden. Sin embargo, la salida correspondiente comienza con "FN2", luego "FN3" y luego "FN1". No hay nada de malo en este orden inicial. Así es como funciona la concurrencia, de manera irregular. El resto de las cadenas de salida aparecen como se llamaron sus funciones.

Después de que el cuerpo de la función principal se unió al hilo maestro, esperó a que el hilo maestro se completara. Para que se complete el hilo maestro, todas las colas tienen que estar vacías. Cada valor de la cola corresponde a la ejecución de su hilo correspondiente. Entonces, para que cada cola se vacíe, su hilo tiene que ejecutarse por ese número de veces; Hay elementos en la cola.

Cuando el hilo maestro y sus hilos han sido ejecutados y terminados, la función principal continúa ejecutando. Y muestra: "El programa ha terminado.".

Conclusión

Un grupo de hilos es un conjunto de hilos. Cada hilo es responsable de llevar a cabo sus propias tareas. Las tareas son funciones. En teoría, las tareas siempre vienen. Realmente no terminan, como se ilustra en el ejemplo anterior. En algunos ejemplos prácticos, los datos se comparten entre hilos. Para compartir datos, el programador necesita conocimiento de condicional_variable, función asincrónica, promesa y futuro. Esa es una discusión por otro tiempo.