Wait-Job
Attende fino a quando uno o tutti i processi di PowerShell in esecuzione nella sessione si trovano 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:
- Completi
- 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 processo personalizzati, ad esempio processi del flusso di lavoro e istanze di processi pianificati. Per abilitare Wait-Job
l'attesa dei 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 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 di $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 al termine del 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. Illustra anche 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 di ambito Using è stato introdotto in Windows PowerShell 3.0. Per altre informazioni sul modificatore using scope, vedere about_Remote_Variables.
Il quarto comando usa Invoke-Command
per eseguire un Wait-Job
comando nelle sessioni. Usa il parametro Any per attendere fino a quando il primo processo nei computer remoti non termina lo stato.
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 di 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 termina 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 un .ps1'estensione del nome file aggiunta o aggiornata nell'ultima settimana.
Il terzo comando usa Wait-Job
per attendere che il processo non sia in 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 usando Invoke-Command
$s = New-PSSession -ComputerName Server01, Server02, Server03
$j = Invoke-Command -Session $s -ScriptBlock {Get-Process} -AsJob
$j | Wait-Job
In questo esempio viene illustrato 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
utilizzato per determinare se un Get-Process
comando in esecuzione nelle sessioni in tre computer remoti è in 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 di $s
.
Il comando usa il parametro AsJob per eseguire il comando in modo asincrono come processo. Il comando restituisce un oggetto processo, esattamente come i processi avviati usando Start-Job
e 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 fino al completamento di tutti i processi specificati prima di visualizzare il prompt.
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 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.
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, restituisce o termina l'attesa, Wait-Job
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 Wait-Job
cmdlet. 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.
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 secondi. Il valore predefinito, -1, indica che il cmdlet attende fino al termine del processo. La tempistica inizia quando si invia il Wait-Job
comando, non il Start-Job
comando.
Se questa volta viene superata, l'attesa termina e l'esecuzione continua, 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 in uno stato di terminazione. Se l'attesa termina perché il valore del parametro Timeout viene superato, 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:
- Completi
- Non riuscito
- Arrestato
- Suspended
- Disconnesso
Wait-Job
Per indirizzare a continuare ad attendere i processi Suspended e Disconnected, usare il parametro Force.