FeaturedNOTICIAS

Cómo utilizar el procesamiento de subprocesos múltiples en scripts Bash – CloudSavvy IT


gato jugando con hilo
Aleksey Mnogosmyslov / Shutterstock.com

La programación de subprocesos múltiples siempre ha sido de interés para los desarrolladores para aumentar el rendimiento de las aplicaciones y optimizar la utilización de recursos. Esta guía le presentará los conceptos básicos de la codificación multiproceso de Bash.

Qué es esto programación multihilo?

Una imagen vale más que mil palabras y esto es cierto cuando se trata de mostrar la diferencia entre la programación de un solo subproceso (1) y la programación de múltiples subprocesos (> 1) en Bash:

sleep 1
sleep 1 & sleep 1

(Último comando) Un simple comando de una línea de dos subprocesos que ejecutará dos procesos de suspensión en paralelo, uno en segundo plano

Nuestra primera programación de múltiples subprocesos o configuración de mini script de una sola línea no podría haber sido más simple; en la primera fila, dormimos un segundo usando el sleep 1 mando. En cuanto al usuario, un solo hilo estaba realizando una única pausa de un segundo.

En la segunda línea, tenemos dos comandos de suspensión de un segundo. Los combinamos usando un & separador, que no solo actúa como un separador entre los dos sleep comandos, sino también como indicador para que Bash inicie el primer comando en un hilo en segundo plano.

Normalmente, finaliza un comando con un punto y coma (;). Esto ejecutará el comando y solo entonces procederá al siguiente comando que aparece detrás del punto y coma. Por ejemplo, ejecutando sleep 1; sleep 1 tomaría poco más de dos segundos: exactamente un segundo para el primer comando, un segundo para el segundo y una pequeña cantidad de sobrecarga del sistema para cada uno de los dos comandos.

Sin embargo, en lugar de terminar un comando con un punto y coma, puede usar otros terminadores de comando que Bash reconoce como &, && Y ||. El && la sintaxis no tiene nada que ver con la programación de subprocesos múltiples, simplemente hace esto; proceda con la ejecución del segundo comando solo si el primero tiene éxito. El || es lo contrario de && y ejecutará el segundo comando solo si el primero falla.

Volver a la programación de subprocesos múltiples, utilizando & ya que nuestro terminador de comandos iniciará un proceso en segundo plano ejecutando el comando que lo precede. Luego procede inmediatamente a ejecutar el siguiente comando en el shell actual, dejando que el proceso en segundo plano (hilo) se ejecute solo.

En la salida del comando podemos ver el inicio de un proceso en segundo plano (como lo indica [1] 445317 Dónde está 445317 es el ID de proceso o PID del proceso en segundo plano que acaba de comenzar e [1] se indica que este es nuestro primer proceso de antecedentes) y posteriormente se termina (como lo indica [1]+ Done sleep 1).

Si desea ver otro ejemplo de gestión de procesos en segundo plano, consulte nuestro artículo Bash Automation and Scripting Basics (Part 3). Además, los trucos de terminación del proceso Bash pueden ser de interés.

Ahora mostramos que en realidad estamos ejecutando dos sleep procesos simultáneamente:

time sleep 1; echo 'done'
time $(sleep 1 & sleep 1); echo 'done'

Ejecutar dos subprocesos suspendidos en paralelo, con uno en segundo plano, usando una subcapa

Aqui comenzamos el nuestro sleep proceso a continuación time y podemos ver cómo nuestro comando de un solo subproceso se ejecutó durante exactamente 1.003 segundos antes de que se devolviera el indicador de la línea de comandos.

Sin embargo, en el segundo ejemplo, tomó aproximadamente la misma cantidad de tiempo (1,005 segundos) a pesar de que estábamos ejecutando dos períodos de suspensión (y procesos), aunque no consecutivos. Nuevamente usamos un proceso en segundo plano para el primer comando de suspensión, que conduce a una ejecución (semi) paralela, es decir, de múltiples subprocesos.

También usamos un contenedor de subcapa ($(...)) alrededor de nuestros dos comandos de sueño para combinarlos a continuación time. ¿Cómo podemos ver el nuestro? done la salida se muestra en 1.005 segundos y luego los dos sleep 1 los comandos deben ejecutarse al mismo tiempo. Es interesante el aumento muy pequeño en el tiempo de procesamiento total (0,002 segundos) que puede explicarse fácilmente por el tiempo que se tarda en iniciar una subcapa y el tiempo que se tarda en iniciar un proceso en segundo plano.

Gestión de procesos de subprocesos múltiples (y en segundo plano)

En Bash, la codificación de subprocesos múltiples normalmente implica subprocesos en segundo plano desde un script principal de una línea o un script Bash completo. Básicamente, puede pensar en la codificación de subprocesos múltiples en Bash como el inicio de varios subprocesos en segundo plano. Cuando comienza a codificar utilizando varios subprocesos, rápidamente queda claro que esos subprocesos generalmente requieren cierta administración. Por ejemplo, tomemos el ejemplo ficticio en el que comenzamos cinco períodos de suspensión (y procesos) simultáneos en un guión Bash;

#!/bin/bash

sleep 10 & 
sleep 600 & 
sleep 1200 & 
sleep 1800 & 
sleep 3600 &

Ejecución de cinco subprocesos de suspensión paralelos en segundo plano desde un script

Cuando ejecutamos el script (después de hacerlo ejecutable usando chmod +x rest.sh), ¡no vemos ninguna salida! Incluso si actuamos jobs (el comando que muestra los trabajos en segundo plano en curso), no se produce ningún resultado. ¿Cómo?

La razón es que el shell que se usó para iniciar este script (es decir, el shell actual) no es el mismo shell (ni el mismo hilo; para empezar a pensar en términos del subshell como un hilo en sí mismo) que ejecutó el comandos de sueño reales o ponerlos en segundo plano. Fue más bien el (sub) shell que se inició cuando ./rest.sh el fue ejecutado.

Cambiemos nuestro script agregando jobs dentro del guión. Esto asegurará que jobs se ejecuta desde dentro del (sub) shell donde es relevante, el mismo desde el que se iniciaron los periodos de reposo (y procesos).

Agregue el comando de trabajo en el script

En esta ocasión podemos ver la lista de procesos en segundo plano iniciados gracias al jobs comando al final del script. También podemos ver sus PID (identificadores de proceso). Estos PID son muy importantes cuando se trata de gestionar y gestionar procesos en segundo plano.

Otra forma de obtener el identificador del proceso en segundo plano es consultarlo inmediatamente después de colocar un programa / proceso en segundo plano:

#!/bin/bash

sleep 10 & 
echo ${!}
sleep 600 & 
echo ${!}
sleep 1200 & 
echo ${!}
sleep 1800 & 
echo ${!}
sleep 3600 &
echo ${!}

Consulte el PID (ID de proceso) del último proceso en segundo plano para comenzar a usar $ {!}

Similar al nuestro jobs comando (con nuevos PID ahora cuando reiniciamos nuestro rest.sh script), gracias a Bash ${!} se repite la variable, ahora veremos los cinco PID mostrados casi inmediatamente después de iniciar el script: los diversos procesos de suspensión se han insertado en subprocesos en segundo plano uno tras otro.

The wait Command

Una vez que hemos iniciado nuestros procesos en segundo plano, no tenemos nada que hacer más que esperar a que finalicen. Sin embargo, cuando cada proceso en segundo plano está realizando una tarea secundaria compleja y necesitamos el script principal (que inició los procesos en segundo plano) para reanudar la ejecución cuando uno o más procesos en segundo plano terminan, necesitamos código adicional para manejarlo.

Ampliemos ahora nuestro script con el wait comando para administrar nuestros hilos en segundo plano:

#!/bin/bash

sleep 10 & 
T1=${!}
sleep 600 & 
T2=${!}
sleep 1200 & 
T3=${!}
sleep 1800 & 
T4=${!}
sleep 3600 &
T5=${!}

echo "This script started 5 background threads which are currently executing with PID's ${T1}, ${T2}, ${T3}, ${T4}, ${T5}."
wait ${T1}
echo "Thread 1 (sleep 10) with PID ${T1} has finished!"
wait ${T2}
echo "Thread 2 (sleep 600) with PID ${T2} has finished!"

Aquí hemos ampliado nuestro guión con dos wait comandos que esperan el final del PID conectado al primer y segundo subproceso. Después de 10 segundos, existe nuestro primer hilo y se nos notifica lo mismo. Paso a paso, este script hará lo siguiente: iniciar cinco subprocesos casi simultáneamente (aunque el inicio de los subprocesos en sí sigue siendo secuencial y no paralelo) donde cada uno de los cinco sleepcorrerán en paralelo.

Luego, el script principal informa (secuencialmente) que se está creando el subproceso y luego espera a que termine el ID de proceso del primer subproceso. Cuando eso suceda, señalará secuencialmente el final del primer hilo y comenzará una espera hasta el final del segundo hilo, etc.

Usando los modismos de Bash &, ${!} y el wait El comando nos brinda una gran flexibilidad cuando se trata de ejecutar múltiples subprocesos en paralelo (como subprocesos en segundo plano) en Bash.

Terminando

En este artículo, hemos explorado los conceptos básicos de las secuencias de comandos multiproceso de Bash. Hemos introducido el operador de proceso en segundo plano (&) utilizando algunos ejemplos fáciles de seguir que muestran tanto de un solo subproceso como de varios subprocesos sleep comandos. A continuación, analizamos cómo gestionar los procesos en segundo plano a través de los modismos de Bash de uso común. ${!} Y wait. También exploramos el jobs comando para ver los subprocesos / procesos que se ejecutan en segundo plano.

Si disfrutó leyendo este artículo, consulte nuestro artículo Hacks de terminación del proceso Bash.

TE INTERESA>>  Netflix lanza tráiler y fecha de estreno definitiva de la temporada 4 del revival de 'Karate Kid'

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

Botón volver arriba