Compartilhar via

Wait-Job

  • Referência
Módulo:
Microsoft.PowerShell.Core

Suprime o prompt de comando até que um ou todos os trabalhos em segundo plano do Windows PowerShell em execução na sessão sejam concluídos.

Sintaxe

Wait-Job
    [-Any]
    [-Timeout <Int32>]
    [-Force]
    [-Id] <Int32[]>
    [<CommonParameters>]
Wait-Job
    [-Job] <Job[]>
    [-Any]
    [-Timeout <Int32>]
    [-Force]
    [<CommonParameters>]
Wait-Job
    [-Any]
    [-Timeout <Int32>]
    [-Force]
    [-Name] <String[]>
    [<CommonParameters>]
Wait-Job
    [-Any]
    [-Timeout <Int32>]
    [-Force]
    [-InstanceId] <Guid[]>
    [<CommonParameters>]
Wait-Job
    [-Any]
    [-Timeout <Int32>]
    [-Force]
    [-State] <JobState>
    [<CommonParameters>]
Wait-Job
    [-Any]
    [-Timeout <Int32>]
    [-Force]
    [-Filter] <Hashtable>
    [<CommonParameters>]

Description

O cmdlet de trabalho de espera aguarda a conclusão dos trabalhos em segundo plano do Windows PowerShell antes de exibir o prompt de comando. Você pode aguardar até que qualquer trabalho em segundo plano seja concluído ou até que todos os trabalhos em segundo plano sejam concluídos e você possa definir um tempo máximo de espera para o trabalho.

Quando os comandos no trabalho são concluídos, wait-job exibe o prompt de comando e retorna um objeto de trabalho para que você possa redirecioná-lo para outro comando.

Você pode usar cmdlet wait-job para aguardar trabalhos em segundo plano, como aqueles que foram iniciados usando o cmdlet Start-Job ou o parâmetro asJob do cmdlet Invoke-Command. Para obter mais informações sobre trabalhos em segundo plano do Windows PowerShell, consulte about_Jobs.

A partir do Windows PowerShell 3.0, o cmdlet de trabalho de espera também aguarda por tipos de trabalho personalizados, como trabalhos de fluxo de trabalho e instâncias de trabalhos agendados. Para habilitar wait-job a aguardar trabalhos de um tipo específico, importe o módulo que dá suporte ao tipo de trabalho personalizado para a sessão antes de executar o cmdlet Get-Job, usando o cmdlet Import-Module ou usando ou obtendo um cmdlet no módulo. Para obter informações sobre um tipo de trabalho personalizado específico, consulte a documentação do recurso de tipo de trabalho personalizado.

Exemplos

Exemplo 1: Aguardar todos os trabalhos

PS C:\> Get-Job | Wait-Job

Esse comando aguarda que todos os trabalhos em segundo plano em execução na sessão terminem.

Exemplo 2: aguarde os trabalhos iniciados em computadores remotos usando Start-Job

PS C:\> $s = New-PSSession Server01, Server02, Server03
PS C:\> Invoke-Command -Session $s -ScriptBlock {Start-Job -Name Date1 -ScriptBlock {Get-Date}}
PS C:\> $done = Invoke-Command -Session $s -Command {Wait-Job -Name Date1}
PS C:\> $done.Count
3

Este exemplo mostra como usar o cmdlet Wait-Job com trabalhos iniciados em computadores remotos usando o cmdlet Start-Job. Os comandos de trabalho inicial e são enviados para o computador remoto usando o cmdlet Invoke-Command.

Este exemplo usa wait-job para determinar se um comando Get-Date em execução como um trabalho em segundo plano em três computadores diferentes foi concluído.

O primeiro comando cria uma sessão do Windows PowerShell (PSSession) em cada um dos três computadores remotos e os armazena na variável $s.

O segundo comando usa Invoke-Command para executar start-job em cada uma das três sessões em $s. Todos os trabalhos se chamam Date1.

O terceiro comando usa Invoke-Command para executar wait-job . Esse comando aguarda a conclusão dos trabalhos date1 em cada computador. Ele armazena a coleção resultante (matriz) de objetos de trabalho na variável $done.

O quarto comando usa a propriedade Count da matriz de objetos de trabalho na variável $done para determinar quantos trabalhos foram concluídos.

Exemplo 3: Determinar quando o primeiro trabalho em segundo plano é concluído

PS C:\> $s = New-PSSession (Get-Content Machines.txt)
PS C:\> $c = 'Get-EventLog -LogName System | where {$_.EntryType -eq "error" --and $_.Source -eq "LSASRV"} | Out-File Errors.txt'
PS C:\> Invoke-Command -Session $s -ScriptBlock {Start-Job -ScriptBlock {$Using:c}
PS C:\> Invoke-Command -Session $s -ScriptBlock {Wait-Job -Any}

Este exemplo usa o parâmetro Any de wait-job para determinar quando o primeiro de muitos trabalhos em segundo plano em execução na sessão atual são concluídos. Ele também mostra como usar o cmdlet wait-job para aguardar a conclusão de trabalhos remotos.

O primeiro comando cria um de PSSession em cada um dos computadores listados no arquivo Machines.txt e armazena os objetos PSSession na variável $s. O comando usa o cmdlet Get-Content para obter o conteúdo do arquivo. O comando Get-Content está entre parênteses para garantir que ele seja executado antes do comando New-PSSession.

O segundo comando armazena uma cadeia de comandos Get-EventLog, entre aspas, na variável $c.

O terceiro comando usa Invoke-Command cmdlet para executar Start-Job em cada uma das sessões em $s. O comando Start-Job inicia um trabalho em segundo plano que executa o comando Get-EventLog na variável $c.

O comando usa o modificador de escopo Using para indicar que a variável de $c foi definida no computador local. O modificador de escopo Using é introduzido no Windows PowerShell 3.0. Para obter mais informações sobre o Usando o modificador de escopo, consulte about_Remote_Variables (https://go.microsoft.com/fwlink/?LinkID=252653).

O quarto comando usa Invoke-Command para executar um comando de trabalho de espera nas sessões. Ele usa o parâmetro Any para aguardar até que o primeiro trabalho nos computadores remotos seja concluído.

Exemplo 4: Definir um tempo de espera para trabalhos em computadores remotos

PS C:\> $s = New-PSSession Server01, Server02, Server03
PS C:\> $jobs = Invoke-Command -Session $s -ScriptBlock {Start-Job -ScriptBlock {Get-Date}}
PS C:\> $done = Invoke-Command -Session $s -ScriptBlock {Wait-Job -Timeout 30}

Este exemplo mostra como usar o parâmetro Timeout de wait-job para definir um tempo de espera máximo para os trabalhos em execução em computadores remotos.

O primeiro comando cria um PSSession em cada um dos três computadores remotos (Server01, Server02 e Server03) e armazena os objetos PSSession na variável $s.

O segundo comando usa Invoke-Command para executar Start-Job em cada um dos objetos de PSSession em $s. Ele armazena os objetos de trabalho resultantes na variável $jobs.

O terceiro comando usa Invoke-Command para executar wait-job em cada uma das sessões no $s. O comando wait-job determina se todos os comandos foram concluídos dentro de 30 segundos. Ele usa o parâmetro Timeout com um valor de 30 para estabelecer o tempo máximo de espera e armazena os resultados do comando na variável $done.

Nesse caso, após 30 segundos, somente o comando no computador Server02 foi concluído. wait-job termina a espera, exibe o prompt de comando e retorna o objeto que representa o trabalho que foi concluído.

A variável $done contém um objeto de trabalho que representa o trabalho executado no Server02.

Exemplo 5: aguarde até que um dos vários trabalhos seja concluído

PS C:\> Wait-Job -id 1,2,5 -Any

Esse comando identifica três trabalhos por suas IDs e aguarda até que qualquer um deles seja concluído. O prompt de comando retorna quando o primeiro trabalho é concluído.

Exemplo 6: aguarde um período e permita que o trabalho continue em segundo plano

PS C:\> Wait-Job -Name "DailyLog" -Timeout 120

Esse comando aguarda 120 segundos (dois minutos) para que o trabalho do DailyLog seja concluído. Se o trabalho não for concluído nos próximos dois minutos, o prompt de comando retornará de qualquer maneira e o trabalho continuará sendo executado em segundo plano.

Exemplo 7: aguarde um trabalho por nome

PS C:\> Wait-Job -Name "Job3"

Esse comando usa o nome do trabalho para identificar o trabalho para o qual aguardar.

Exemplo 8: aguarde trabalhos no computador local iniciados com Start-Job

PS C:\> $j = Start-Job -ScriptBlock {Get-ChildItem *.ps1| where {$_lastwritetime -gt ((Get-Date) - (New-TimeSpan -Days 7))}}
PS C:\> $j | Wait-Job

Este exemplo mostra como usar o cmdlet de trabalho de espera com trabalhos iniciados no computador local usando de Trabalho Inicial.

Esses comandos iniciam um trabalho que obtém os arquivos de script do Windows PowerShell que foram adicionados ou atualizados na última semana.

O primeiro comando usa start-job para iniciar um trabalho em segundo plano no computador local. O trabalho executa um comando Get-ChildItem que obtém todos os arquivos que têm uma extensão de nome de arquivo .ps1 que foram adicionados ou atualizados na última semana.

O terceiro comando usa wait-job para aguardar até que o trabalho seja concluído. Quando o trabalho é concluído, o comando exibe o objeto de trabalho, que contém informações sobre o trabalho.

Exemplo 9: aguarde os trabalhos iniciados em computadores remotos usando Invoke-Command

PS C:\> $s = New-PSSession Server01, Server02, Server03
PS C:\> $j = Invoke-Command -Session $s -ScriptBlock {Get-Process} -AsJob
PS C:\> $j | Wait-Job

Este exemplo mostra como usar wait-job com trabalhos iniciados em computadores remotos usando o parâmetro asJob de Invoke-Command. Ao usar AsJob, o trabalho é criado no computador local e os resultados são retornados automaticamente para o computador local, mesmo que o trabalho seja executado nos computadores remotos.

Este exemplo usa wait-job para determinar se um comando Get-Process em execução nas sessões em três computadores remotos foi concluído.

O primeiro comando cria objetos PSSession em três computadores e os armazena na variável $s.

O segundo comando usa Invoke-Command para executar Get-Process em cada uma das três sessões em $s. O comando usa o parâmetro AsJob para executar o comando de forma assíncrona como um trabalho em segundo plano. O comando retorna um objeto de trabalho, assim como os trabalhos iniciados usando Start-Job e o objeto de trabalho é armazenado na variável $j.

O terceiro comando usa um operador de pipeline (|) para enviar o objeto de trabalho em $j para o cmdlet Wait-Job. Um comando Invoke-Command não é necessário nesse caso, pois o trabalho reside no computador local.

Exemplo 10: aguarde um trabalho que tenha uma ID

PS C:\> Get-Job

Id   Name     State      HasMoreData     Location             Command
--   ----     -----      -----------     --------             -------
1    Job1     Completed  True            localhost,Server01.. get-service
4    Job4     Completed  True            localhost            dir | where

PS C:\> Wait-Job -Id 1

Esse comando aguarda o trabalho com um valor de ID de 1.

Parâmetros

-Any

Indica que esse cmdlet exibe o prompt de comando e retorna o objeto de trabalho quando qualquer trabalho é concluído. Por padrão, espera até que todos os trabalhos especificados sejam concluídos antes de exibir o prompt.

Tipo:SwitchParameter
Cargo:Named
Valor padrão:None
Obrigatório:False
Aceitar a entrada de pipeline:False
Aceitar caracteres curinga:False

-Filter

Especifica uma tabela de condições de hash. Esse cmdlet aguarda trabalhos que atendam a todas as condições na tabela de hash. Insira uma tabela de hash em que as chaves são propriedades de trabalho e os valores são valores de propriedade do trabalho.

Esse parâmetro funciona apenas em tipos de trabalho personalizados, como trabalhos de fluxo de trabalho e trabalhos agendados. Ele não funciona em trabalhos em segundo plano padrão, como aqueles criados usando o cmdlet do Start-Job. Para obter informações sobre o suporte para esse parâmetro, consulte o tópico de ajuda para o tipo de trabalho.

Esse parâmetro foi introduzido no Windows PowerShell 3.0.

Tipo:Hashtable
Cargo:0
Valor padrão:None
Obrigatório:True
Aceitar a entrada de pipeline:True
Aceitar caracteres curinga:False

-Force

Indica que esse cmdlet continua aguardando trabalhos no estado Suspenso ou Desconectado. Por padrão, de trabalho de espera retorna ou encerra a espera quando os trabalhos estão em um dos seguintes estados:

  • Concluído
  • Falhou
  • Parado
  • Suspenso
  • Desconectado

Esse parâmetro foi introduzido no Windows PowerShell 3.0.

Tipo:SwitchParameter
Cargo:Named
Valor padrão:None
Obrigatório:False
Aceitar a entrada de pipeline:False
Aceitar caracteres curinga:False

-Id

Especifica uma matriz de IDs de trabalhos para os quais esse cmdlet aguarda.

A ID é um inteiro que identifica exclusivamente o trabalho na sessão atual. É mais fácil lembrar e digitar do que a ID da instância, mas ela é exclusiva apenas na sessão atual. Você pode digitar uma ou mais IDs, separadas por vírgulas. Para localizar a ID de um trabalho, digite Get-Job.

Tipo:Int32[]
Cargo:0
Valor padrão:None
Obrigatório:True
Aceitar a entrada de pipeline:True
Aceitar caracteres curinga:False

-InstanceId

Especifica uma matriz de IDs de instância de trabalhos para os quais esse cmdlet aguarda. O padrão é todos os trabalhos.

Uma ID de instância é um GUID que identifica exclusivamente o trabalho no computador. Para localizar a ID da instância de um trabalho, use get-job.

Tipo:Guid[]
Cargo:0
Valor padrão:None
Obrigatório:True
Aceitar a entrada de pipeline:True
Aceitar caracteres curinga:False

-Job

Especifica os trabalhos para os quais esse cmdlet aguarda. Insira uma variável que contenha os objetos de trabalho ou um comando que obtém os objetos de trabalho. Você também pode usar um operador de pipeline para enviar objetos de trabalho para o cmdlet Wait-Job. Por padrão, espera por todos os trabalhos criados na sessão atual.

Tipo:Job[]
Cargo:0
Valor padrão:None
Obrigatório:True
Aceitar a entrada de pipeline:True
Aceitar caracteres curinga:False

-Name

Especifica nomes amigáveis de trabalhos para os quais esse cmdlet aguarda.

Tipo:String[]
Cargo:0
Valor padrão:None
Obrigatório:True
Aceitar a entrada de pipeline:True
Aceitar caracteres curinga:False

-State

Especifica um estado de trabalho. Esse cmdlet aguarda apenas trabalhos no estado especificado. Os valores aceitáveis para este parâmetro são:

  • NotStarted
  • Executando
  • Concluído
  • Falhou
  • Parado
  • Bloqueado
  • Suspenso
  • Desconectado
  • Suspender
  • Parar

Para obter mais informações sobre estados de trabalho, consulte de Enumeração JobState na biblioteca MSDN.

Tipo:JobState
Valores aceitos:NotStarted, Running, Completed, Failed, Stopped, Blocked, Suspended, Disconnected, Suspending, Stopping, AtBreakpoint
Cargo:0
Valor padrão:None
Obrigatório:True
Aceitar a entrada de pipeline:True
Aceitar caracteres curinga:False

-Timeout

Especifica o tempo máximo de espera para cada trabalho em segundo plano, em segundos. O valor padrão, -1, indica que o cmdlet aguarda até que o trabalho seja concluído. O tempo começa quando você envia o comando wait-job, não o comando Start-Job.

Se esse tempo for excedido, a espera será encerrada e o prompt de comando retornará, mesmo que o trabalho ainda esteja em execução. O comando não exibe nenhuma mensagem de erro.

Tipo:Int32
Aliases:TimeoutSec
Cargo:Named
Valor padrão:None
Obrigatório:False
Aceitar a entrada de pipeline:False
Aceitar caracteres curinga:False

Entradas

System.Management.Automation.RemotingJob

Você pode canalizar um objeto de trabalho para este cmdlet.

Saídas

System.Management.Automation.PSRemotingJob

Esse cmdlet retorna objetos de trabalho que representam os trabalhos concluídos. Se a espera terminar porque o valor do parâmetro Timeout for excedido, wait-job não retornará nenhum objeto.

Observações

  • Por padrão, de trabalho de espera retorna ou encerra a espera quando os trabalhos estão em um dos seguintes estados:
  • Concluído
  • Falhou
  • Parado
  • Suspenso
  • Desconectado para direcionar de trabalho de espera para continuar aguardando trabalhos suspensos e desconectados, use o parâmetro Force.