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 trabalho fornecidos pelo PowerShell para dar suporte à simultaneidade.

• RemoteJob - Comandos e scripts são 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 na máquina local.
• PSTaskJob ou ThreadJob - 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.

A execução de scripts remotamente, em uma máquina separada ou em um processo separado, fornece um ótimo isolamento. Quaisquer erros que ocorram no trabalho remoto não afetam outros trabalhos em execução ou a sessão pai que iniciou o trabalho. No entanto, a camada remota adiciona sobrecarga, incluindo a serialização de objetos. Todos os objetos são serializados e desserializados à medida que são passados entre a sessão pai e a sessão remota (trabalho). A serialização de objetos de dados grandes e complexos pode consumir grandes quantidades de recursos de computação e memória e transferir grandes quantidades de dados pela rede.

Os trabalhos baseados em thread não são tão robustos quanto os 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 trave o processo, todos os outros trabalhos no processo serão encerrados.

No entanto, os trabalhos baseados em thread exigem menos sobrecarga. Eles não usam a camada remota ou a serialização. Os objetos resultantes são retornados como referências a objetos ativos 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.

Existem duas maneiras de contornar essa situação:

1. Use Invoke-Command para criar trabalhos que são executados em sessões desconectadas. Para obter mais informações, consulte about_Remote_Jobs.
2. Use Start-Process para criar um novo processo em vez de um trabalho. Para saber mais, confira Start-Process.

Os cmdlets de trabalho

• Start-Job - Inicia um trabalho em segundo plano em um computador local.
• Get-Job - Obtém os trabalhos em segundo plano que foram iniciados na 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 concluídos.
• 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 é executado entre 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 demore muito 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 do trabalho.

Você pode salvar o objeto de trabalho em uma variável e usá-lo com os outros cmdlets de trabalho 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}

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 um estado de Concluído ou Com falha. Um trabalho também pode estar 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 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 de trabalho 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 na $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é o momento. 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 do uso do 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 será 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ê usasse o Receive-Job cmdlet para obter os resultados do trabalho agora, os resultados estariam 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. Quando o uso usa 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 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 esperar por um período de tempo predeterminado. Esse comando usa o parâmetro Timeout para limitar a espera a 120 segundos. Quando o tempo expira, o prompt de comando retorna, mas o trabalho continua a ser executado em segundo plano.

Wait-Job -ID 10 -Timeout 120

Interrompendo 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 $job trabalho na 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 vários motivos. o objeto job 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 na conexão com o servidor remoto com a seguinte mensagem de erro: "Acesso negado".

Confira também

• about_Job_Details
• about_PSSessions
• about_Remote
• about_Remote_Jobs
• about_Thread_Jobs
• Invoke-Command
• Get-Job
• Receive-Job
• Remove-Job
• Start-Job
• Stop-Job
• Wait-Job