XARGS multiprocesado con ejemplos

Si eres nuevo en Xargs, o no se que Xargs es todavía, lea nuestros xargs para principiantes con ejemplos primero. Si ya está un poco acostumbrado a Xargs, y puede escribir básico Xargs declaraciones de línea de comando sin mirar el manual, entonces este artículo lo ayudará a ser más avanzado con Xargs en la línea de comando, especialmente haciéndolo multiproteo.

En este tutorial aprenderás:

• Cómo utilizar Xargs -P (modo múltiple) desde la línea de comando en Bash
• Ejemplos de uso avanzado utilizando múltiples subprocesos Xargs Desde la línea de comando en Bash
• Una comprensión más profunda de cómo aplicar Xargs múltiples subprocesos a su código bash existente

Requisitos y convenciones de software utilizados

Ejemplo 1: Llamar a otro shell de fiesta con la entrada compilada de Xargs

Después de que uno usa para aprender Xargs, él o ella pronto encontrará eso, mientras que Xargs Permite hacer muchas cosas poderosas por sí misma: el poder de Xargs parece estar limitado por su incapacidad para ejecutar múltiples comandos en secuencia.

Por ejemplo, supongamos que tenemos un directorio que tiene subdirectorios nombrados 00 a 10 (11 en total). Y, para cada uno de estos subdirectorios, queremos atravesarlo y verificar si un archivo nombrado archivo.TXT existe, y si es así gato (y fusionar usando >>) El contenido de este archivo a un archivo Total_file.TXT en el directorio donde el 00 a 10 Los directorios son. Intentemos hacer esto con Xargs En varios pasos:

$ mkdir 00 01 02 03 04 05 06 07 08 09 10 $ ls 00 01 02 03 04 04 05 06 07 08 09 10 $ echo 'a'> 03/archivo.Txt $ echo 'b'> 07/archivo.TXT $ echo 'c'> 10/archivo.TXT 

Aquí primero creamos 11 directorios, 00 a 10 y siguiente crear 3 muestra archivo.TXT archivos en los subdirectorios 03, 07 y 10.

$ Find . -Archivo MAXDEPTH 2 -PE F -NAME.TXT ./10/archivo.TXT ./07/archivo.TXT ./03/archivo.TXT 

Luego escribimos un encontrar comandar para localizar todo archivo.TXT archivos que comienzan en el directorio actual (.) y que hasta un máximo de 1 nivel de subdirectorios:

$ Find . -Archivo MAXDEPTH 2 -PE F -NAME.txt | xargs -i  cat > ./Total_file.txt $ cat total_file.txt c b a 

El -Maxdepth 2 indica el directorio actual (1) y Todos los subdirectorios de este directorio (por lo tanto, la máxima profundidad de 2).

Finalmente usamos Xargs (con el recomendado y preferido cadena de reemplazo como pasó a los xargs -I reemplazar la cadena opción) para atender el contenido de dicho archivo ubicado por el encontrar comando en un archivo en el directorio actual nombrado Total_file.TXT.

Algo agradable notar aquí es que, aunque uno pensaría en Xargs como posteriormente ejecutando múltiples gato comandos todos la redirección al mismo archivo, uno puede usar > (Salir al nuevo archivo, crear el archivo si aún no existe, y sobrescribir cualquier archivo con el mismo nombre ya) en lugar de >> (Agregar a un archivo y crear el archivo si aún no está existente)!

El ejercicio hasta ahora algo así como cumplió nuestros requisitos, pero no coincidió con el requisito exactamente, a saber, no atraviesa los subdirectorios. Tampoco usó el >> redirección como se especifica, aunque usar eso en este caso aún habría funcionado.

El desafío con la ejecución de múltiples comandos (como el específico cd comando requerido para cambiar el directorio/traverse al subdirectorio) desde adentro Xargs es que 1) son muy difíciles de codificar, y 2) puede no ser posible codificar esto en absoluto.

Sin embargo, hay una forma diferente y fácil de entender para codificar esto, y una vez que sepa cómo hacer esto, es probable que lo use en abundancia. Vamos a sumergirnos.

$ RM Total_file.TXT 

Primero limpiamos nuestra salida anterior.

$ ls -d-color = nunca [0-9] [0-9] | xargs -i  echo 'cd ; Si [-r ./archivo.TXT ]; Entonces el archivo CAT.txt >>… /total_file.TXT; fi 'cd 00; Si [-r ./archivo.TXT ]; Entonces el archivo CAT.txt >>… /total_file.TXT; fi CD 01; Si [-r ./archivo.TXT ]; Entonces el archivo CAT.txt >>… /total_file.TXT; fi CD 02; Si [-r ./archivo.TXT ]; Entonces el archivo CAT.txt >>… /total_file.TXT; fi CD 03; Si [-r ./archivo.TXT ]; Entonces el archivo CAT.txt >>… /total_file.TXT; fi CD 04; Si [-r ./archivo.TXT ]; Entonces el archivo CAT.txt >>… /total_file.TXT; fi CD 05; Si [-r ./archivo.TXT ]; Entonces el archivo CAT.txt >>… /total_file.TXT; fi CD 06; Si [-r ./archivo.TXT ]; Entonces el archivo CAT.txt >>… /total_file.TXT; fi CD 07; Si [-r ./archivo.TXT ]; Entonces el archivo CAT.txt >>… /total_file.TXT; fi CD 08; Si [-r ./archivo.TXT ]; Entonces el archivo CAT.txt >>… /total_file.TXT; fi CD 09; Si [-r ./archivo.TXT ]; Entonces el archivo CAT.txt >>… /total_file.TXT; fi CD 10; Si [-r ./archivo.TXT ]; Entonces el archivo CAT.txt >>… /total_file.TXT; FI 

A continuación, formulamos un comando, esta vez usando LS que enumerará todos los directorios que corresponden al [0-9] [0-9] Expresión regular (lea nuestro avanzado Bash Regex con un artículo de ejemplos para obtener más información sobre expresiones regulares).

También usamos Xargs, Pero esta vez (en comparación con ejemplos anteriores) con un eco comando que generará exactamente lo que nos gustaría hacer, incluso si requiere más de uno o muchos comandos. Piense en esto como un mini-script.

También usamos cd para cambiar en directorios como se enumeran por el LS -D (solo directorios) comando (que como nota al margen está protegida por el --color = nunca cláusula evitando cualquier código de color en el LS Salida de sesgar nuestros resultados) y verifique si el archivo archivo.TXT ¿Está ahí en el subdirectorio usando un Si [-r .. dominio. Si existe, nosotros gato el archivo.TXT en … /Total_file.TXT. Nota la … como el cd en el comando nos ha colocado en el subdirectorio!

Ejecutamos esto para ver cómo funciona (después de todo, solo el eco es ejecutado; No pasará nada). El código generado se ve muy bien. Vamos a dar un paso más allá y ejecutar lo mismo:

$ ls -d-color = nunca [0-9] [0-9] | xargs -i  echo 'cd ; Si [-r ./archivo.TXT ]; Entonces el archivo CAT.txt >>… /total_file.TXT; fi '| xargs -i  bash -c "" $ Cat Total_file.txt a b c 

Ahora ejecutamos el script total usando un específico (y siempre lo mismo, yo.mi. Te encontrarás escribiendo | xargs -i bash -c "" con cierta regularidad) comando, que ejecuta lo que fue generado por el eco precedirlo: xargs -i bash -c "". Básicamente, esto le dice al intérprete bash que ejecute lo que se le pasó a él, y esto para cualquier código generado. Muy poderoso!

Ejemplo 2: Xargs multiproceso

Aquí echaremos un vistazo a dos diferentes Xargs comandos, uno ejecutado sin ejecución paralela (multiproceso), el otro con. Considere la diferencia entre los siguientes dos ejemplos:

$ tiempo para i en $ (SEQ 1 5); hacer eco $ [$ Random % 5 + 1]; hecho | xargs -i  echo "sueño ; echo '!  '"| xargs -i  bash -c"  "hecho! 5 Hechos! 5 Hechos! 2! 4 Hechos! 1 Real 0m17.016S usuario 0m0.017S SYS 0M0.003s 

$ tiempo para i en $ (SEQ 1 5); hacer eco $ [$ Random % 5 + 1]; hecho | xargs -i  echo "sueño ; echo '!  '"| xargs -p5 -i  bash -c"  "hecho! 1 hecho! 3 Hechos! 3 Hechos! 3 Hechos! 5 Real 0m5.019S usuario 0m0.036S SYS 0M0.015S 

La diferencia entre las dos líneas de comando reales es pequeña; solo agregamos -P5 En la segunda línea de comando. Sin embargo, el tiempo de ejecución (según lo medido por el tiempo Prefijo de comando) es significativo. Descubra por qué (y por qué la salida difiere!).

En el primer ejemplo, creamos un para bucle que se ejecutará 5 veces (debido a la subshell $ (SEQ 1 5) Generando números de 1 a 5) y en él hacemos eco de un número aleatorio entre 1 y 5. A continuación, mucho en línea con el último ejemplo, enviamos esta salida al comando del sueño y también salimos la duración como parte del hecho de que! eco. Finalmente enviamos esto para ser ejecutado por un comando de subshell bash, nuevamente de manera similar a nuestro último ejemplo.

La salida del primer comando funciona así; ejecutar un sueño, resultado de salida, ejecutar el siguiente sueño, etc.

Sin embargo, el segundo comando cambia completamente esto. Aquí agregamos -P5 que básicamente comienza 5 hilos paralelos de una vez!

La forma en que funciona este comando es: Iniciar subprocesos de X (según lo definido por la opción -p) y procesarlos simultáneamente. Cuando se complete un hilo, tome una entrada nueva inmediatamente, no espere a que otros hilos terminen primero. La última parte de esa descripción no es aplicable aquí (solo sería si hubiera menos hilos especificados por -PAG entonces el número de 'líneas' de entrada dada, o en otras palabras, menos subprocesos paralelos estarían disponibles y luego el número de filas de entrada).

El resultado es que los hilos que terminan primero, aquellos con un tiempo de sueño al azar corto, regresan primero y emiten su 'hecho!' declaración. El tiempo de ejecución total también cae de aproximadamente 17 segundos a aproximadamente 5 segundos exactamente en el tiempo real del reloj. Fresco!

Conclusión

Usando Xargs es una de las formas más avanzadas y también una de las más poderosas de codificar en Bash. Pero no se detiene solo en usar Xargs! En este artículo exploramos así la ejecución paralela multiproceso a través del -PAG opción para Xargs. También miramos a las subshells de llamar usando ps y finalmente introdujimos un método para pasar declaraciones de múltiples mando directamente a Xargs usando un bash -c llamada subshell.

Poderoso? Creemos que sí! Déjanos tus pensamientos.

Tutoriales de Linux relacionados:

• Ejemplos sobre cómo usar el comando XARGS en Linux
• Scripting de bash y gestión de procesos multiprocesos en el ..
• Xargs para principiantes con ejemplos
• Mastering Bash Script Loops
• Cómo usar subshells Bash dentro de declaraciones
• Comandos básicos de Linux
• Cosas que hacer después de instalar Ubuntu 20.04 fossa focal Linux
• Comandos de Linux: los 20 comandos más importantes que necesitas ..
• Sistema colgado de Linux? Cómo escapar a la línea de comando y ..
• Cosas para instalar en Ubuntu 20.04