Condividi tramite

Wait-Job

  • Riferimento
Modulo:
Microsoft.PowerShell.Core

Attende che uno o tutti i processi di lavoro di PowerShell in esecuzione nella sessione 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 cmdlet Wait-Job attende che un job si trovi in uno stato di terminazione prima di continuare l'esecuzione. Gli stati di terminazione sono:

  • Finito
  • Fallito
  • Fermato
  • Sospeso
  • Sconnesso

È 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 stati Suspended o Disconnected.

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

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

A partire da Windows PowerShell 3.0, il cmdlet Wait-Job attende anche i tipi di processi personalizzati, ad esempio processi del flusso di lavoro e istanze di processi pianificati. Per consentire Wait-Job di attendere i processi di un determinato 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 particolare tipo di processo personalizzato, vedere la documentazione della funzionalità del tipo di processo personalizzato.

Esempio

Esempio 1: Attendere tutti i lavori

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

Questo esempio illustra 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.

Questo esempio usa Wait-Job per determinare se un comando Get-Date 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 variabile $s.

Il secondo comando usa Invoke-Command per eseguire Start-Job in ognuna delle tre sessioni in $s. Tutti i lavori 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 (array) di oggetti di lavoro nella variabile $done.

Il quarto comando utilizza la proprietà Count dell'array di oggetti di processo nella variabile $done per determinare quanti processi sono completati.

Esempio 3: Determinare quando termina il primo compito

$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 Wait-Job per attendere il completamento dei processi remoti.

Il primo comando crea una PSSession in ognuno dei computer elencati nel file Machines.txt e memorizza 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 che esegue il comando Get-EventLog nella variabile $c.

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

Il quarto comando usa Invoke-Command per eseguire un comando Wait-Job nelle sessioni. Usa il parametro Any per attendere fino a quando il primo processo nei computer remoti raggiunge lo stato di terminazione.

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 un PSSession in ognuno dei 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 ogni oggetto PSSession in $s. Archivia gli oggetti lavoro 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, è stato completato solo il comando nel computer Server02. Wait-Job termina l'attesa, restituisce l'oggetto che rappresenta il processo completato e visualizza il prompt dei comandi.

La variabile $done 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 compito.

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

Wait-Job -Name "DailyLog" -Timeout 120

Questo comando attende 120 secondi (due minuti) affinché il processo DailyLog sia completato. 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 lavoro 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 avviati sul computer locale 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 Wait-Job con i processi avviati nel computer locale usando Start-Job.

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

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

Il terzo comando usa Wait-Job per attendere finché 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 usando 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 utilizzando il parametro AsJob di per 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.

Questo esempio usa Wait-Job per determinare se un comando Get-Process 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 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. Il comando restituisce un oggetto processo, proprio come i processi avviati usando Start-Jobe 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 si trova nel computer locale.

Esempio 10: Attendere un lavoro 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 processo con un valore ID pari a 1.

Parametri

-Any

Indica che questo cmdlet restituisce l'oggetto di processo e continua l'esecuzione quando uno qualsiasi dei processi termina. 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 proprietà del processo e i valori sono valori delle proprietà del processo.

Questo parametro funziona solo su tipi di processi personalizzati, ad esempio processi del flusso di lavoro e processi pianificati. Non funziona su processi standard, ad esempio quelli creati usando il cmdlet Start-Job. Per informazioni sul supporto per 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 Sospeso o Disconnesso. Per impostazione predefinita, Wait-Job restituisce o termina l'attesa, quando i processi si trovano in uno degli stati seguenti:

  • Finito
  • Fallito
  • Interrotto
  • Sospeso
  • Sconnesso

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 attività per i quali questo cmdlet attende.

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

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

-InstanceId

Specifica un array di ID delle istanze dei processi per cui questo cmdlet attende. Il valore predefinito è tutte le attività.

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

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

-Job

Specifica le attività per le quali il cmdlet attende. Specificare una variabile che contiene gli oggetti di processo o un comando che ottiene gli oggetti di processo. È anche possibile usare un operatore pipeline per inviare oggetti di processo al cmdlet Wait-Job. Per impostazione predefinita, Wait-Job attende tutti i lavori 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 lavori in attesa dei 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 di lavoro. Questo cmdlet attende solo i processi nello stato specificato. I valori accettabili per questo parametro sono:

  • Non Iniziato
  • Corsa
  • Finito
  • Fallito
  • Fermato
  • Bloccato
  • Sospeso
  • Sconnesso
  • Sospensione
  • Fermarsi

Per altre informazioni sugli stati del processo, 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. La temporizzazione inizia quando si invia il comando Wait-Job, non il comando Start-Job.

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 instradare 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 oppure mette fine all'attesa quando i processi si trovano in uno degli stati seguenti:

  • Finito
  • Fallito
  • Interrotto
  • Sospeso
  • Sconnesso

Per indirizzare Wait-Job a continuare ad attendere i processi Sospesi e Disconnessi, utilizzare il parametro Force.