Aleksey Mnogosmyslov / Shutterstock.com

A programação multithread sempre foi do interesse dos desenvolvedores para aumentar o desempenho do aplicativo e otimizar o uso de recursos. Este guia apresentará a você os fundamentos da codificação multithread do Bash.

O que é programação multi-threaded?

Uma imagem vale mais que mil palavras, e isso vale quando se trata de mostrar a diferença entre a programação de single (1) thread e programação de multi-thread (> 1) no Bash:

sleep 1
 sleep 1 & sleep 1
 

(Último comando) Um comando simples de uma linha de dois threads que irá executar dois processos de hibernação em paralelo, um em segundo plano

Nossa primeira configuração de programação multi-threaded ou mini script de uma linha não poderia ter sido mais simples; na primeira linha, dormimos por um segundo usando o sleep 1 comando. No que diz respeito ao usuário, um único thread estava executando uma única suspensão de um segundo.

Na segunda linha, temos dois comandos de suspensão de um segundo. Nós nos juntamos a eles usando um & separador, que não atua apenas como um separador entre os dois sleep comandos, mas também como um indicador para o Bash iniciar o primeiro comando em um thread em segundo plano.

Normalmente, alguém terminaria um comando usando um ponto e vírgula (;) Fazer isso executaria o comando e só então passaria para o próximo comando listado atrás do ponto-e-vírgula. Por exemplo, executando sleep 1; sleep 1 levaria pouco mais de dois segundos - exatamente um segundo para o primeiro comando, um segundo para o segundo e uma pequena quantidade de sobrecarga do sistema para cada um dos dois comandos.

No entanto, em vez de terminar um comando com um ponto-e-vírgula, pode-se usar outros terminadores de comando que o Bash reconhece como &, && e ||. O && a sintaxe não está relacionada à programação multithread, ela simplesmente faz isso; prossiga com a execução do segundo comando somente se o primeiro comando foi bem-sucedido. O || é o oposto de && e executará o segundo comando somente se o primeiro comando falhar.

Retornando à programação multi-thread, usando & pois nosso terminador de comando iniciará um processo em segundo plano executando o comando anterior. Em seguida, ele prossegue imediatamente com a execução do próximo comando no shell atual, deixando o processo de segundo plano (thread) para ser executado por si mesmo.

Na saída do comando, podemos ver um processo em segundo plano sendo iniciado (conforme indicado por [1] 445317 Onde 445317 é o ID do processo ou PID do processo em segundo plano recém-iniciado e [1] é um indicado que este é o nosso primeiro processo em segundo plano) e, posteriormente, sendo encerrado (conforme indicado por [1]+ Done sleep 1)

Se desejar ver um exemplo adicional de manipulação de processos em segundo plano, consulte nosso artigo Bash Automation and Scripting Basics (Parte 3). Além disso, os Hacks de rescisão do processo Bash podem ser interessantes.

Vamos agora provar que estamos efetivamente executando dois sleep processos ao mesmo tempo:

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

Executar dois threads de sono em paralelo, com um em segundo plano, usando uma subcamada

Aqui começamos nosso sleep processo sob time e podemos ver como nosso comando de thread único foi executado por exatamente 1,003 segundos antes de nosso prompt de linha de comando ser retornado.

No entanto, no segundo exemplo, demorou quase o mesmo tempo (1,005 segundos), embora estivéssemos executando dois períodos (e processos) de sono, embora não consecutivamente. Novamente usamos um processo em segundo plano para o primeiro comando sleep, levando à execução (semi-) paralela, ou seja, multi-threaded.

Também usamos um invólucro de subshell ($(...)) em torno de nossos dois comandos de suspensão para combiná-los sob time. Como podemos ver nosso done saída mostra em 1,005 segundos e, portanto, os dois sleep 1 os comandos devem ser executados simultaneamente. Interessante é o aumento muito pequeno no tempo de processamento geral (0,002 segundos), que pode ser facilmente explicado pelo tempo necessário para iniciar um subshell e o tempo necessário para iniciar um processo em segundo plano.

Gerenciamento de processos multiencadeados (e em segundo plano)

No Bash, a codificação multithread normalmente envolverá threads em segundo plano de um script principal de uma linha ou script Bash completo. Em essência, pode-se pensar na codificação multithread no Bash como o início de várias threads em segundo plano. Quando alguém começa a codificar usando vários encadeamentos, rapidamente fica claro que esses encadeamentos geralmente requerem algum manuseio. Por exemplo, pegue o exemplo fictício em que iniciamos cinco períodos (e processos) simultâneos de sono em um script Bash;

#!/bin/bash
 
 sleep 10 & 
 sleep 600 & 
 sleep 1200 & 
 sleep 1800 & 
 sleep 3600 &
 

Executando cinco threads paralelos de sono em segundo plano a partir de um script

Quando iniciamos o script (depois de torná-lo executável usando chmod +x rest.sh), não vemos saída! Mesmo se executarmos jobs (o comando que mostra quaisquer trabalhos em segundo plano em andamento), não há saída. Por quê?

A razão é que o shell que foi usado para iniciar este script (ou seja, o shell atual) não é o mesmo shell (nem o mesmo segmento; para começar a pensar em termos de subshells como threads em si) que executou o sono real comandos ou colocados em segundo plano. Era mais o (sub) shell que foi iniciado quando ./rest.sh foi executado.

Vamos mudar nosso script adicionando jobs dentro do script. Isso irá garantir que jobs é executado de dentro do (sub) shell onde for relevante, o mesmo de onde os períodos (e processos) de sono foram iniciados.

Adicionando o comando jobs no script

Desta vez, podemos ver a lista de processos em segundo plano sendo iniciados graças ao jobs comando no final do script. Também podemos ver seus PID's (Identificadores de Processo). Esses PIDs são muito importantes quando se trata de manipular e gerenciar processos em segundo plano.

Outra maneira de obter o identificador de processo em segundo plano é consultá-lo imediatamente após colocar um programa / processo em segundo plano:

#!/bin/bash
 
 sleep 10 & 
 echo ${!}
 sleep 600 & 
 echo ${!}
 sleep 1200 & 
 echo ${!}
 sleep 1800 & 
 echo ${!}
 sleep 3600 &
 echo ${!}
 

Consultando o PID (ID do processo) do último processo em segundo plano a ser iniciado usando $ {!}

Semelhante ao nosso jobs comando (com novos PIDs agora enquanto reiniciamos nosso rest.sh script), graças ao Bash ${!} variável sendo ecoada, agora veremos os cinco PIDs sendo exibidos quase imediatamente após o início do script: os vários processos de suspensão foram colocados em threads de fundo um após o outro.

The wait Command

Depois de iniciar nossos processos em segundo plano, não temos mais nada a fazer do que esperar que eles sejam concluídos. No entanto, quando cada processo em segundo plano está executando uma subtarefa complexa e precisamos do script principal (que iniciou os processos em segundo plano) para retomar a execução quando um ou mais dos processos em segundo plano termina, precisamos de código adicional para lidar com isso.

Vamos expandir nosso script agora com o wait comando para lidar com nossos threads de fundo:

#!/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!"
 

Aqui nós expandimos nosso roteiro com dois wait comandos que aguardam o término do PID anexado ao primeiro e ao segundo threads. Após 10 segundos, nosso primeiro tópico existe e somos notificados do mesmo. Passo a passo, este script fará o seguinte: iniciar cinco threads quase ao mesmo tempo (embora o início dos threads em si ainda seja sequencial e não paralelo) onde cada um dos cinco sleepdo será executado em paralelo.

O script principal então (sequencialmente) relata sobre o encadeamento criado e, subsequentemente, espera que o ID do processo do primeiro encadeamento seja encerrado. Quando isso acontecer, ele irá relatar sequencialmente sobre o acabamento do primeiro thread e iniciar uma espera até que o segundo thread termine, etc.

Usando os idiomas Bash &, ${!} e a wait comando nos dá grande flexibilidade quando se trata de executar vários threads em paralelo (como threads de fundo) no Bash.

Empacotando

Neste artigo, exploramos os fundamentos do script Bash multithread. Introduzimos o operador de processo em segundo plano (&) usando alguns exemplos fáceis de seguir, mostrando ambos os segmentos único e multithread sleep comandos. A seguir, vimos como lidar com processos em segundo plano por meio dos idiomas Bash comumente usados ${!} e wait. Nós também exploramos o jobs comando para ver threads / processos em execução em segundo plano.

Se você gostou de ler este artigo, dê uma olhada em nosso artigo Bash Process Termination Hacks. Aproveitar!

Adicione ao Google Notícias
Neste artigo
  1. O que é programação multi-threaded?
  2. Gerenciamento de processos multiencadeados (e em segundo plano)
  3. Empacotando