Wait-Job

Modulo:

Microsoft.PowerShell.Core

Elimina il prompt dei comandi fino a quando non vengono completati uno o tutti i processi in background Windows PowerShell in esecuzione nella sessione.

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 cmdlet Wait-Job attende il completamento di Windows PowerShell processi in background prima di visualizzare il prompt dei comandi. È possibile attendere il completamento di uno o di tutti i processi in background ed è possibile impostare un tempo di attesa massimo per il processo.

Al completamento dei comandi nel processo, Wait-Job visualizza il prompt dei comandi e restituisce un oggetto processo da inviare tramite pipe a un altro comando.

È possibile usare il cmdlet Wait-Job per attendere i processi in background, ad esempio quelli avviati usando il cmdlet Start-Job o il parametro AsJob del cmdlet Invoke-Command. Per altre informazioni sui processi in background di Windows PowerShell, vedere about_Jobs.

A partire da Windows PowerShell 3.0, il cmdlet Wait-Job attende anche i tipi di processo personalizzati, ad esempio processi del flusso di lavoro e istanze di processi pianificati. Per consentire a Wait-Job di attendere i processi di un particolare tipo, importare il modulo che supporta il tipo di processo personalizzato nella sessione prima di eseguire il cmdlet Get-Job, usando il cmdlet Import-Module oppure 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

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

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

Esempio 2: Attendere l'avvio dei processi nei computer remoti 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

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

In questo esempio viene utilizzato Wait-Job per determinare se un comando Get-Date in esecuzione come processo in background 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 variabile $s.

Il secondo comando usa Invoke-Command per eseguire 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 processi Date1 in ogni computer. Archivia la raccolta risultante (matrice) di oggetti processo nella variabile $done.

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

Esempio 3: Determinare quando termina il primo processo in background

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}

In questo esempio viene utilizzato il parametro Any di Wait-Job per determinare quando vengono completati i primi processi in background in esecuzione nella sessione corrente. Illustra anche come usare il cmdlet Wait-Job per attendere il completamento dei processi remoti.

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

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

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

Il comando usa il modificatore di ambito Using per indicare che la variabile $c è stata definita nel computer locale. Il modificatore di ambito Using è stato introdotto in Windows PowerShell 3.0. Per altre informazioni sul modificatore using scope, vedere about_Remote_Variables (https://go.microsoft.com/fwlink/?LinkID=252653).

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

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

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}

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 di tre computer remoti (Server01, Server02 e Server03) e quindi archivia gli oggetti PSSession nella variabile $s.

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

Il terzo comando usa Invoke-Command per eseguire Wait-Job in ognuna delle sessioni in $s. Il comando Wait-Job 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 variabile $done.

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

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

Esempio 5: Attendere il completamento di uno dei diversi processi

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

Questo comando identifica tre processi in base agli ID e attende il completamento di uno di essi. Il prompt dei comandi restituisce al termine del primo processo.

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

PS C:\> 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, il prompt dei comandi restituisce comunque e il processo continua a essere eseguito in background.

Esempio 7: Attendere un processo in base al nome

PS C:\> 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

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

In questo esempio viene illustrato come usare il cmdlet Wait-Job con i 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 in background nel computer locale. Il processo esegue un comando Get-ChildItem che ottiene tutti i file con un'estensione di file .ps1 aggiunta o aggiornata nell'ultima settimana.

Il terzo comando usa Wait-Job per attendere il completamento del processo. 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 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

In questo esempio viene illustrato come usare Wait-Job con 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 usato Wait-Job per determinare se viene completato un comando Get-Process in esecuzione nelle sessioni in tre computer remoti.

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

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

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

Esempio 10: Attendere un processo con UN 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

Questo comando attende il completamento del processo con ID 1.

Parametri

-Any

Indica che questo cmdlet visualizza il prompt dei comandi e restituisce l'oggetto processo al termine di qualsiasi processo. Per impostazione predefinita, Wait-Job attende il completamento di tutti i processi specificati prima che venga visualizzata la richiesta.

Type:	SwitchParameter
Position:	Named
Default value:	None
Required:	False
Accept pipeline input:	False
Accept wildcard characters:	False

-Filter

Specifica una tabella hash di condizioni. Questo cmdlet attende i processi che soddisfano tutte le condizioni della 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 sui processi in background standard, ad esempio quelli creati usando il cmdlet Start-Job . 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.

Type:	Hashtable
Position:	0
Default value:	None
Required:	True
Accept pipeline input:	True
Accept wildcard characters:	False

-Force

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

• Completi
• Non riuscito
• Arrestato
• Suspended
• Disconnesso

Questo parametro è stato introdotto in Windows PowerShell 3.0.

Type:	SwitchParameter
Position:	Named
Default value:	None
Required:	False
Accept pipeline input:	False
Accept wildcard characters:	False

-Id

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

L'ID è un intero che identifica in modo univoco il processo nella sessione corrente. È più semplice ricordare e digitare l'ID dell'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.

Type:	Int32[]
Position:	0
Default value:	None
Required:	True
Accept pipeline input:	True
Accept wildcard characters:	False

-InstanceId

Specifica una matrice di ID istanza di processi per i quali 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.

Type:	Guid[]
Position:	0
Default value:	None
Required:	True
Accept pipeline input:	True
Accept wildcard characters:	False

-Job

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

Type:	Job[]
Position:	0
Default value:	None
Required:	True
Accept pipeline input:	True
Accept wildcard characters:	False

-Name

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

Type:	String[]
Position:	0
Default value:	None
Required:	True
Accept pipeline input:	True
Accept wildcard characters:	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
• Bloccato
• Suspended
• Disconnesso
• Suspending
• Stopping

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

Type:	JobState
Accepted values:	NotStarted, Running, Completed, Failed, Stopped, Blocked, Suspended, Disconnected, Suspending, Stopping, AtBreakpoint
Position:	0
Default value:	None
Required:	True
Accept pipeline input:	True
Accept wildcard characters:	False

-Timeout

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

Se questo valore viene superato, l'attesa termina e viene restituito il prompt dei comandi, anche se il processo è ancora in esecuzione. Il comando non visualizza alcun messaggio di errore.

Type:	Int32
Aliases:	TimeoutSec
Position:	Named
Default value:	None
Required:	False
Accept pipeline input:	False
Accept wildcard characters:	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 completati. Se l'attesa termina perché viene superato il valore del parametro Timeout , Wait-Job non restituisce alcun oggetto.

Note

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

• Completi
• Non riuscito
• Arrestato
• Suspended
• Disconnesso Per indirizzare Wait-Job per continuare ad attendere i processi Suspended e Disconnected, usare il parametro Force .

Collegamenti correlati

• Get-Job
• Invoke-Command
• Receive-Job
• Remove-Job
• Resume-Job
• Start-Job
• Stop-Job
• Suspend-Job
• about_Jobs
• about_Job_Details
• about_Remote_Jobs
• about_Remote_Variables