Condividi tramite

Wait-Job

  • Riferimento
Modulo:
Microsoft.PowerShell.Core

Attende che uno o tutti i processi di PowerShell in esecuzione nella sessione non siano in uno stato di terminazione.

Sintassi

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>]

Descrizione

Il Wait-Job cmdlet attende che un processo si trovi in uno stato di terminazione prima di continuare l'esecuzione. Gli stati di terminazione sono:

  • Completato
  • Non riuscito
  • Arrestato
  • Suspended
  • Disconnesso

È possibile attendere fino a quando un processo specificato o tutti i processi si trovano in uno stato di terminazione. È anche possibile impostare un tempo di attesa massimo per il processo usando il parametro Timeout oppure usare il parametro Force per attendere un processo negli Suspended stati o Disconnected .

Al termine dei comandi del processo, Wait-Job restituisce un oggetto processo e continua l'esecuzione.

È possibile usare il Wait-Job cmdlet per attendere l'avvio dei processi usando il Start-Job cmdlet o il parametro AsJob del Invoke-Command cmdlet . Per altre informazioni sui processi, vedere about_Jobs.

A partire da Windows PowerShell 3.0, il Wait-Job cmdlet attende anche i tipi di processi personalizzati, ad esempio processi del flusso di lavoro e istanze dei processi pianificati. Per consentire Wait-Job l'attesa di processi di un particolare tipo, importare il modulo che supporta il tipo di processo personalizzato nella sessione prima di eseguire il Get-Job cmdlet, usando il Import-Module cmdlet o usando o ottenendo un cmdlet nel modulo. Per informazioni su un tipo di processo personalizzato particolare, vedere la documentazione relativa alla funzionalità del tipo di processo personalizzato.

Esempio

Esempio 1: Attendere tutti i processi

Get-Job | Wait-Job

Questo comando attende il completamento di tutti i processi in esecuzione nella sessione.

Esempio 2: Attendere l'avvio dei processi nei computer remoti usando Start-Job

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

3

In questo esempio viene illustrato come usare il cmdlet con i Wait-Job processi avviati nei computer remoti usando il Start-Job cmdlet . Entrambi Start-Job i comandi e Wait-Job vengono inviati al computer remoto usando il Invoke-Command cmdlet .

In questo esempio viene Wait-Job usato per determinare se un Get-Date comando in esecuzione come processo in tre computer diversi è terminato.

Il primo comando crea una sessione di Windows PowerShell (PSSession) in ognuno dei tre computer remoti e li archivia nella $s variabile .

Il secondo comando usa Invoke-Command per l'esecuzione Start-Job in ognuna delle tre sessioni in $s. Tutti i processi sono denominati Date1.

Il terzo comando usa Invoke-Command per eseguire Wait-Job. Questo comando attende il completamento dei Date1 processi in ogni computer. Archivia la raccolta risultante (matrice) di oggetti processo nella $done variabile .

Il quarto comando usa la proprietà Count della matrice di oggetti processo nella $done variabile per determinare il numero di processi completati.

Esempio 3: Determinare quando termina il primo processo

$s = New-PSSession -ComputerName (Get-Content -Path .\Machines.txt)
$c = 'Get-EventLog -LogName System | Where-Object {$PSItem.EntryType -eq "error" --and $PSItem.Source -eq "LSASRV"} | Out-File -FilePath Errors.txt'
Invoke-Command -Session $s -ScriptBlock {Start-Job -ScriptBlock {$Using:c}
Invoke-Command -Session $s -ScriptBlock {Wait-Job -Any}

In questo esempio viene utilizzato il parametro Any di Wait-Job per determinare quando il primo di molti processi in esecuzione nella sessione corrente si trova in uno stato di terminazione. Viene inoltre illustrato come usare il cmdlet per attendere il Wait-Job completamento dei processi remoti.

Il primo comando crea una sessione PSSession in ognuno dei computer elencati nel file Machines.txt e archivia gli oggetti PSSession nella $s variabile. Il comando usa il Get-Content cmdlet per ottenere il contenuto del file. Il Get-Content comando è racchiuso tra parentesi per assicurarsi che venga eseguito prima del New-PSSession comando.

Il secondo comando archivia una Get-EventLog stringa di comando, tra virgolette, nella $c variabile .

Il terzo comando usa il Invoke-Command cmdlet per l'esecuzione Start-Job in ognuna delle sessioni in $s. Il Start-Job comando avvia un processo che esegue il Get-EventLog comando nella $c variabile .

Il comando usa il modificatore Using scope per indicare che la $c variabile è stata definita nel computer locale. Il modificatore Using scope è stato introdotto in Windows PowerShell 3.0. Per altre informazioni sul modificatore Uso dell'ambito, vedere about_Remote_Variables.

Il quarto comando usa Invoke-Command per eseguire un Wait-Job comando nelle sessioni. Usa il parametro Any per attendere il primo processo nei computer remoti.

Esempio 4: Impostare un tempo di attesa per i processi nei computer remoti

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

In questo esempio viene illustrato come usare il parametro Timeout di Wait-Job per impostare un tempo di attesa massimo per i processi in esecuzione nei computer remoti.

Il primo comando crea una sessione PSSession in ognuno dei tre computer remoti (Server01, Server02 e Server03) e quindi archivia gli oggetti PSSession nella $s variabile.

Il secondo comando usa Invoke-Command per l'esecuzione Start-Job in ognuno degli oggetti PSSession in $s. Archivia gli oggetti processo risultanti nella $jobs variabile .

Il terzo comando usa Invoke-Command per l'esecuzione Wait-Job in ognuna delle sessioni in $s. Il Wait-Job comando determina se tutti i comandi sono stati completati entro 30 secondi. Usa il parametro Timeout con un valore pari a 30 per stabilire il tempo di attesa massimo e quindi archivia i risultati del comando nella $done variabile.

In questo caso, dopo 30 secondi, solo il comando nel computer Server02 è stato completato. Wait-Job termina l'attesa, restituisce l'oggetto che rappresenta il processo completato e visualizza il prompt dei comandi.

La $done variabile contiene un oggetto processo che rappresenta il processo eseguito in Server02.

Esempio 5: Attendere il completamento di uno dei diversi processi

Wait-Job -id 1,2,5 -Any

Questo comando identifica tre processi in base ai relativi ID e attende fino a quando uno di essi non è in uno stato di terminazione. L'esecuzione continua al termine del primo processo.

Esempio 6: Attendere un periodo, quindi consentire al processo di continuare in background

Wait-Job -Name "DailyLog" -Timeout 120

Questo comando attende il completamento del processo DailyLog di 120 secondi (due minuti). Se il processo non viene completato nei due minuti successivi, l'esecuzione continua e il processo continua a essere eseguito in background.

Esempio 7: Attendere un processo in base al nome

Wait-Job -Name "Job3"

Questo comando usa il nome del processo per identificare il processo per il quale attendere.

Esempio 8: Attendere i processi nel computer locale avviato con Start-Job

$j = Start-Job -ScriptBlock {Get-ChildItem -Filter *.ps1| Where-Object {$PSItem.LastWriteTime -gt ((Get-Date) - (New-TimeSpan -Days 7))}}
$j | Wait-Job

In questo esempio viene illustrato come usare il cmdlet con i Wait-Job processi avviati nel computer locale usando Start-Job.

Questi comandi avviano un processo che ottiene i file script di Windows PowerShell aggiunti o aggiornati nell'ultima settimana.

Il primo comando usa Start-Job per avviare un processo nel computer locale. Il processo esegue un Get-ChildItem comando che ottiene tutti i file con estensione ps1 che sono stati aggiunti o aggiornati nell'ultima settimana.

Il terzo comando usa Wait-Job per attendere che il processo non sia in uno stato di terminazione. Al termine del processo, il comando visualizza l'oggetto processo, che contiene informazioni sul processo.

Esempio 9: Attendere l'avvio dei processi nei computer remoti tramite Invoke-Command

$s = New-PSSession -ComputerName Server01, Server02, Server03
$j = Invoke-Command -Session $s -ScriptBlock {Get-Process} -AsJob
$j | Wait-Job

Questo esempio illustra come usare Wait-Job con i processi avviati nei computer remoti usando il parametro AsJob di Invoke-Command. Quando si usa AsJob, il processo viene creato nel computer locale e i risultati vengono restituiti automaticamente al computer locale, anche se il processo viene eseguito nei computer remoti.

In questo esempio viene Wait-Job usato per determinare se un Get-Process comando in esecuzione nelle sessioni in tre computer remoti è in uno stato di terminazione.

Il primo comando crea oggetti PSSession in tre computer e li archivia nella $s variabile .

Il secondo comando usa Invoke-Command per l'esecuzione Get-Process in ognuna delle tre sessioni in $s. Il comando usa il parametro AsJob per eseguire il comando in modo asincrono come processo. Il comando restituisce un oggetto processo, proprio come i processi avviati tramite Start-Jobe l'oggetto processo viene archiviato nella $j variabile .

Il terzo comando usa un operatore pipeline (|) per inviare l'oggetto processo al $j Wait-Job cmdlet . In Invoke-Command questo caso non è necessario un comando, perché il processo risiede nel computer locale.

Esempio 10: Attendere un processo con UN ID

Get-Job

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

Wait-Job -Id 1

Questo comando attende il completamento del processo con ID 1.

Parametri

-Any

Indica che questo cmdlet restituisce l'oggetto processo e continua l'esecuzione al termine di qualsiasi processo. Per impostazione predefinita, Wait-Job attende il completamento di tutti i processi specificati prima di visualizzare il prompt.

Tipo:SwitchParameter
Posizione:Named
Valore predefinito:None
Necessario:False
Accettare l'input della pipeline:False
Accettare caratteri jolly:False

-Filter

Specifica una tabella hash di condizioni. Questo cmdlet attende i processi che soddisfano tutte le condizioni nella tabella hash. Immettere una tabella hash in cui le chiavi sono le proprietà del processo e i valori sono i valori di queste proprietà.

Questo parametro funziona solo su tipi di processo personalizzati, ad esempio i processi del flusso di lavoro e i processi pianificati. Non funziona su processi standard, ad esempio quelli creati usando il Start-Job cmdlet . Per informazioni sul supporto di questo parametro, vedere l'argomento della Guida relativo al tipo di processo.

Questo parametro è stato introdotto in Windows PowerShell 3.0.

Tipo:Hashtable
Posizione:0
Valore predefinito:None
Necessario:True
Accettare l'input della pipeline:True
Accettare caratteri jolly:False

-Force

Indica che questo cmdlet continua ad attendere i processi nello stato Suspended o Disconnected. Per impostazione predefinita, Wait-Job restituisce o termina l'attesa, quando i processi si trovano in uno degli stati seguenti:

  • Completato
  • Non riuscito
  • Arrestato
  • Suspended
  • Disconnesso

Questo parametro è stato introdotto in Windows PowerShell 3.0.

Tipo:SwitchParameter
Posizione:Named
Valore predefinito:None
Necessario:False
Accettare l'input della pipeline:False
Accettare caratteri jolly:False

-Id

Specifica una matrice di ID di processi per cui questo cmdlet attende.

L'ID è un numero intero che identifica in modo univoco il processo nella sessione corrente. È più facile ricordare e digitare l'ID istanza, ma è univoco solo nella sessione corrente. È possibile digitare uno o più ID, separati da virgole. Per trovare l'ID di un processo, digitare Get-Job.

Tipo:Int32[]
Posizione:0
Valore predefinito:None
Necessario:True
Accettare l'input della pipeline:True
Accettare caratteri jolly:False

-InstanceId

Specifica una matrice di ID istanza di processi per cui questo cmdlet attende. Il valore predefinito corrisponde a tutti i processi.

Un ID istanza è un GUID che identifica in modo univoco il processo nel computer. Per trovare l'ID istanza di un processo, usare Get-Job.

Tipo:Guid[]
Posizione:0
Valore predefinito:None
Necessario:True
Accettare l'input della pipeline:True
Accettare caratteri jolly:False

-Job

Specifica i processi per i quali il cmdlet attende. Immettere una variabile che contiene gli oggetti processo o un comando che li ottiene. È anche possibile usare un operatore pipeline per inviare oggetti processo al Wait-Job cmdlet . Per impostazione predefinita, Wait-Job attende tutti i processi creati nella sessione corrente.

Tipo:Job[]
Posizione:0
Valore predefinito:None
Necessario:True
Accettare l'input della pipeline:True
Accettare caratteri jolly:False

-Name

Specifica i nomi descrittivi dei processi per i quali il cmdlet attende.

Tipo:String[]
Posizione:0
Valore predefinito:None
Necessario:True
Accettare l'input della pipeline:True
Accettare caratteri jolly:False

-State

Specifica uno stato del processo. Questo cmdlet attende solo i processi nello stato specificato. I valori validi per questo parametro sono:

  • NotStarted
  • In esecuzione
  • Completato
  • Non riuscito
  • Arrestato
  • Bloccati
  • Suspended
  • Disconnesso
  • Suspending
  • Arresto in corso

Per altre informazioni sugli stati dei processi, vedere Enumerazione JobState.

Tipo:JobState
Valori accettati:NotStarted, Running, Completed, Failed, Stopped, Blocked, Suspended, Disconnected, Suspending, Stopping, AtBreakpoint
Posizione:0
Valore predefinito:None
Necessario:True
Accettare l'input della pipeline:True
Accettare caratteri jolly:False

-Timeout

Specifica il tempo di attesa massimo per ogni processo, espresso in secondi. Il valore predefinito , -1, indica che il cmdlet attende fino al termine del processo. L'intervallo inizia quando si invia il Wait-Job comando, non il Start-Job comando .

Se questo tempo viene superato, l'attesa termina e l'esecuzione continua, anche se il processo è ancora in esecuzione. Il comando non visualizza alcun messaggio di errore.

Tipo:Int32
Alias:TimeoutSec
Posizione:Named
Valore predefinito:None
Necessario:False
Accettare l'input della pipeline:False
Accettare caratteri jolly:False

Input

System.Management.Automation.RemotingJob

È possibile inviare tramite pipe un oggetto processo a questo cmdlet.

Output

System.Management.Automation.PSRemotingJob

Questo cmdlet restituisce oggetti processo che rappresentano i processi in uno stato di terminazione. Se l'attesa termina perché viene superato il valore del parametro Timeout , Wait-Job non restituisce alcun oggetto .

Note

PowerShell include gli alias seguenti per Wait-Job:

  • Tutte le piattaforme:
    • wjb

Per impostazione predefinita, Wait-Job restituisce o termina l'attesa, quando i processi si trovano in uno degli stati seguenti:

  • Completato
  • Non riuscito
  • Arrestato
  • Suspended
  • Disconnesso

Per continuare Wait-Job ad attendere i processi Suspended e Disconnected, usare il parametro Force .