about_Jobs
Descrição breve
Fornece informações sobre como os trabalhos em segundo plano do PowerShell executam um comando ou expressão em segundo plano sem interagir com a sessão atual.
Descrição longa
O PowerShell executa simultaneamente comandos e scripts por meio de trabalhos. Há três tipos de trabalhos fornecidos pelo PowerShell para dar suporte à simultaneidade.
RemoteJob
– Comandos e scripts executados em uma sessão remota. Para obter informações, consulte about_Remote_Jobs.BackgroundJob
– Comandos e scripts são executados em um processo separado no computador local.PSTaskJob
ouThreadJob
– Comandos e scripts são executados em um thread separado dentro do mesmo processo no computador local. Para obter mais informações, consulte about_Thread_Jobs.
Executar scripts remotamente, em um computador separado ou em um processo separado, fornece um grande isolamento. Os erros que ocorrem no trabalho remoto não afetam outros trabalhos em execução ou a sessão pai que iniciou o trabalho. No entanto, a camada de comunicação remota adiciona sobrecarga, incluindo serialização de objeto. Todos os objetos são serializados e desserializados conforme são passados entre a sessão pai e a sessão remota (trabalho). A serialização de grandes objetos de dados complexos pode consumir grandes quantidades de recursos de computação e memória e transferir grandes quantidades de dados pela rede.
Trabalhos baseados em thread não são tão robustos quanto trabalhos remotos e em segundo plano, pois são executados no mesmo processo em threads diferentes. Se um trabalho tiver um erro crítico que trava o processo, todos os outros trabalhos no processo serão encerrados.
No entanto, trabalhos baseados em thread exigem menos sobrecarga. Eles não usam a camada de comunicação remota ou a serialização. Os objetos de resultado são retornados como referências a objetos dinâmicos na sessão atual. Sem essa sobrecarga, os trabalhos baseados em thread são executados mais rapidamente e usam menos recursos do que os outros tipos de trabalho.
Importante
A sessão pai que criou o trabalho também monitora o trabalho status e coleta dados de pipeline. O processo filho do trabalho é encerrado pelo processo pai depois que o trabalho atinge um estado concluído. Se a sessão pai for encerrada, todos os trabalhos filho em execução serão encerrados junto com seus processos filho.
Há duas maneiras de contornar essa situação:
- Use
Invoke-Command
para criar trabalhos executados em sessões desconectadas. Para obter mais informações, consulte about_Remote_Jobs. - Use
Start-Process
para criar um novo processo em vez de um trabalho. Para saber mais, confira Start-Process.
Os cmdlets de trabalho
Cmdlet | Descrição |
---|---|
Start-Job |
Inicia um trabalho em segundo plano em um computador local. |
Get-Job |
Obtém os trabalhos em segundo plano que foram iniciados no |
sessão atual. | |
Receive-Job |
Obtém os resultados de trabalhos em segundo plano. |
Stop-Job |
Interrompe um trabalho em segundo plano. |
Wait-Job |
Suprime o prompt de comando até que um ou todos os trabalhos sejam |
Completa. | |
Remove-Job |
Exclui um trabalho em segundo plano. |
Invoke-Command |
O parâmetro AsJob cria um trabalho em segundo plano em um |
computador remoto. Você pode usar Invoke-Command para executar |
|
qualquer comando de trabalho remotamente, incluindo Start-Job . |
Como iniciar um trabalho no computador local
Para iniciar um trabalho em segundo plano no computador local, use o Start-Job
cmdlet .
Para escrever um Start-Job
comando, coloque o comando que o trabalho executa em chaves ({}
). Use o parâmetro ScriptBlock para especificar o comando .
O comando a seguir inicia um trabalho em segundo plano que executa um Get-Process
comando no computador local.
Start-Job -ScriptBlock {Get-Process}
Quando você inicia um trabalho em segundo plano, o prompt de comando retorna imediatamente, mesmo que o trabalho leve um tempo estendido para ser concluído. É possível continuar a trabalhar na sessão sem interrupção enquanto o trabalho é executado.
O Start-Job
comando retorna um objeto que representa o trabalho. O objeto de trabalho contém informações úteis sobre o trabalho, mas não contém os resultados deste.
Você pode salvar o objeto de trabalho em uma variável e usá-lo com os outros cmdlets job para gerenciar o trabalho em segundo plano. O comando a seguir inicia um objeto de trabalho e salva o objeto de trabalho resultante na $job
variável .
$job = Start-Job -ScriptBlock {Get-Process}
A partir do PowerShell 6.0, você pode usar o operador em segundo plano (&
) no final de um pipeline para iniciar um trabalho em segundo plano. Para obter mais informações, consulte operador em segundo plano.
O uso do operador background é funcionalmente equivalente ao uso do Start-Job
cmdlet no exemplo anterior.
$job = Get-Process &
Obtendo objetos de trabalho
O Get-Job
cmdlet retorna objetos que representam os trabalhos em segundo plano que foram iniciados na sessão atual. Sem parâmetros, Get-Job
retorna todos os trabalhos que foram iniciados na sessão atual.
Get-Job
O objeto de trabalho contém o estado do trabalho, que indica se o trabalho foi concluído. Um trabalho concluído tem o estado Concluído ou Falha. Um trabalho também pode ser Bloqueado ou Em Execução.
Id Name PSJobTypeName State HasMoreData Location Command
-- ---- ------------- ----- ----------- -------- -------
1 Job1 BackgroundJob Complete True localhost Get-Process
Você pode salvar o objeto de trabalho em uma variável e usá-lo para representar o trabalho em um comando posterior. O comando a seguir obtém o trabalho com a ID 1 e o salva na $job
variável .
$job = Get-Job -Id 1
Obtendo os resultados de um trabalho
Quando você executa um trabalho em segundo plano, os resultados não aparecem imediatamente. Para obter os resultados de um trabalho em segundo plano, use o Receive-Job
cmdlet .
No exemplo a seguir, o Receive-Job
cmdlet obtém os resultados do trabalho usando o $job
objeto job na variável .
Receive-Job -Job $job
Handles NPM(K) PM(K) WS(K) VM(M) CPU(s) Id ProcessName
------- ------ ----- ----- ----- ------ -- -----------
103 4 11328 9692 56 1176 audiodg
804 14 12228 14108 100 101.74 1740 CcmExec
668 7 2672 6168 104 32.26 488 csrss
...
Você pode salvar os resultados de um trabalho em uma variável. O comando a seguir salva os resultados do trabalho na $job
variável para a $results
variável .
$results = Receive-Job -Job $job
Obtendo e mantendo resultados parciais do trabalho
O Receive-Job
cmdlet obtém os resultados de um trabalho em segundo plano. Se o trabalho estiver concluído, Receive-Job
obterá todos os resultados do trabalho. Se o trabalho ainda estiver em execução, Receive-Job
obterá os resultados que foram gerados até agora. Você pode executar Receive-Job
comandos novamente para obter os resultados restantes.
Por padrão, Receive-Job
exclui os resultados do cache em que os resultados do trabalho são armazenados. Ao executar Receive-Job
novamente, você obtém apenas os novos resultados que chegaram após a primeira execução.
Os comandos a seguir mostram os resultados dos Receive-Job
comandos executados antes da conclusão do trabalho.
C:\PS> Receive-Job -Job $job
Handles NPM(K) PM(K) WS(K) VM(M) CPU(s) Id ProcessName
------- ------ ----- ----- ----- ------ -- -----------
103 4 11328 9692 56 1176 audiodg
804 14 12228 14108 100 101.74 1740 CcmExec
C:\PS> Receive-Job -Job $job
Handles NPM(K) PM(K) WS(K) VM(M) CPU(s) Id ProcessName
------- ------ ----- ----- ----- ------ -- -----------
68 3 2632 664 29 0.36 1388 ccmsetup
749 22 21468 19940 203 122.13 3644 communicator
905 7 2980 2628 34 197.97 424 csrss
1121 25 28408 32940 174 430.14 3048 explorer
Use o parâmetro Keep para impedir Receive-Job
a exclusão dos resultados do trabalho retornados. Os comandos a seguir mostram o efeito de usar o parâmetro Keep em um trabalho que ainda não foi concluído.
C:\PS> Receive-Job -Job $job -Keep
Handles NPM(K) PM(K) WS(K) VM(M) CPU(s) Id ProcessName
------- ------ ----- ----- ----- ------ -- -----------
103 4 11328 9692 56 1176 audiodg
804 14 12228 14108 100 101.74 1740 CcmExec
C:\PS> Receive-Job -Job $job -Keep
Handles NPM(K) PM(K) WS(K) VM(M) CPU(s) Id ProcessName
------- ------ ----- ----- ----- ------ -- -----------
103 4 11328 9692 56 1176 audiodg
804 14 12228 14108 100 101.74 1740 CcmExec
68 3 2632 664 29 0.36 1388 ccmsetup
749 22 21468 19940 203 122.13 3644 communicator
905 7 2980 2628 34 197.97 424 csrss
1121 25 28408 32940 174 430.14 3048 explorer
Aguardando os resultados
Se você executar um comando que leva muito tempo para ser concluído, poderá usar as propriedades do objeto de trabalho para determinar quando o trabalho é concluído. O comando a seguir usa o Get-Job
objeto para obter todos os trabalhos em segundo plano na sessão atual.
Get-Job
Os resultados aparecem em uma tabela. O status do trabalho aparece na coluna Estado.
Id Name PSJobTypeName State HasMoreData Location Command
-- ---- ------------- ----- ----------- -------- -------
1 Job1 BackgroundJob Complete True localhost Get-Process
2 Job2 BackgroundJob Running True localhost Get-EventLog -Log ...
3 Job3 BackgroundJob Complete True localhost dir -Path C:\* -Re...
Nesse caso, a propriedade State revela que o Trabalho 2 ainda está em execução. Se você usar o Receive-Job
cmdlet para obter os resultados do trabalho agora, os resultados estarão incompletos. Você pode usar o Receive-Job
cmdlet repetidamente para obter todos os resultados. Use a propriedade State para determinar quando o trabalho é concluído.
Você também pode usar o parâmetro Wait do Receive-Job
cmdlet . Ao usar esse parâmetro, o cmdlet não retorna o prompt de comando até que o trabalho seja concluído e todos os resultados estejam disponíveis.
Você também pode usar o Wait-Job
cmdlet para aguardar qualquer um ou todos os resultados do trabalho. Wait-Job
permite aguardar um ou mais trabalhos específicos ou para todos os trabalhos.
O comando a seguir usa o Wait-Job
cmdlet para aguardar um trabalho com a ID 10.
Wait-Job -ID 10
Como resultado, o prompt do PowerShell é suprimido até que o trabalho seja concluído.
Você também pode aguardar um período de tempo predeterminado. Esse comando usa o parâmetro Timeout para limitar a espera a 120 segundos. Quando o tempo expirar, o prompt de comando retornará, mas o trabalho continuará sendo executado em segundo plano.
Wait-Job -ID 10 -Timeout 120
Parando um trabalho
Para interromper um trabalho em segundo plano, use o Stop-Job
cmdlet . O comando a seguir inicia um trabalho para obter todas as entradas no log de eventos do sistema. Ele salva o objeto de trabalho na $job
variável .
$job = Start-Job -ScriptBlock {Get-EventLog -Log System}
O comando a seguir interrompe o trabalho. Ele usa um operador de pipeline (|
) para enviar o trabalho na $job
variável para Stop-Job
.
$job | Stop-Job
Excluindo um trabalho
Para excluir um trabalho em segundo plano, use o Remove-Job
cmdlet . O comando a seguir exclui o trabalho na $job
variável.
Remove-Job -Job $job
Investigando um trabalho com falha
Os trabalhos podem falhar por muitos motivos. o objeto de trabalho contém uma propriedade Reason que contém informações sobre a causa da falha.
O exemplo a seguir inicia um trabalho sem as credenciais necessárias.
$job = Start-Job -ScriptBlock {New-Item -Path HKLM:\Software\MyCompany}
Get-Job $job
Id Name PSJobTypeName State HasMoreData Location Command
-- ---- ------------- ----- ----------- -------- -------
1 Job1 BackgroundJob Failed False localhost New-Item -Path HKLM:...
Inspecione a propriedade Reason para localizar o erro que causou a falha do trabalho.
$job.ChildJobs[0].JobStateInfo.Reason
Nesse caso, o trabalho falhou porque o computador remoto exigia credenciais explícitas para executar o comando. A propriedade Reason contém a seguinte mensagem:
Falha ao conectar-se ao servidor remoto com a seguinte mensagem de erro: "Acesso negado".