Wait-Job

Wait-Job [[-InstanceId] <Guid[]>] [-Any] [-Timeout <int>] [<CommonParameters>]

Wait-Job [-Job] <Job[]> [-Any] [-Timeout <int>] [<CommonParameters>]

Wait-Job [[-Name] <string[]>] [-Any] [-Timeout <int>] [<CommonParameters>]

Wait-Job [-Id] <Int32[]> [-Any] [-Timeout <int>] [<CommonParameters>]

Wait-Job [-State {<NotStarted> | <Running> | <Completed> | <Failed> | <Stopped> | <Blocked>}] [-Any] [-Timeout <int>] [<CommonParameters>]

C:\PS>get-job | wait-job

Beschreibung
-----------
Dieser Befehl wartet, bis die Ausführung aller Hintergrundaufträge in der Sitzung abgeschlossen wurde.

C:\PS>$s = new-pssession server01, server02, server03

C:\PS> invoke-command -session $s -scriptblock {start-job -name Date1 -scriptblock {get-date}}

C:\PS> $done = invoke-command -session $s -command {wait-job -name Date1}

C:\PS> $done.count
3

Beschreibung
-----------
In diesem Beispiel wird gezeigt, wie das Cmdlet "Wait-Job" unter Verwendung des Cmdlet "Start-Job" mit Aufträgen verwendet wird, die auf Remotecomputern gestartet wurden. Der Befehl "Start-Job" und der Befehl "Wait-Job" werden mit dem Cmdlet "Invoke-Command" an den Remotecomputer gesendet.

In diesem Beispiel wird mit Wait-Job bestimmt, ob der Befehl "Get-Date", der als Hintergrundauftrag auf drei verschiedenen Computern ausgeführt wird, abgeschlossen wurde. 

Im ersten Befehl wird eine Windows PowerShell-Sitzung (PSSession) auf jedem der drei Remotecomputer erstellt und in der Variablen "$s" gespeichert. 

Im zweiten Befehl wird mit dem Cmdlet "Invoke-Command" ein Start-Job-Befehl in jeder der drei Sitzungen in $s ausgeführt. Alle Aufträge erhalten den Namen "Date1".

Im dritten Befehl wird mit dem Cmdlet "Invoke-Command" ein Wait-Job-Befehl ausgeführt. Dieser Befehl wartet, bis die Ausführung der Date1-Aufträge auf den einzelnen Computern abgeschlossen ist. Die resultierende Auflistung (Array) von Auftragsobjekten wird in der Variablen "$done" gespeichert. 

Im vierten Befehl wird mit der Count-Eigenschaft des Arrays von Auftragsobjekten in der Variablen "$done" bestimmt, wie viele Aufträge abgeschlossen wurden.

C:\PS>$s = new-pssession (get-content machines.txt)  

C:\PS> $c = 'get-eventlog -log system | where {$_.EntryType -eq "error" -and $_.Source -eq "LSASRV"} | out-file errors.txt'

C:\PS> invoke-command -session $s -scriptblock {param($c)start-job -scriptblock {$c}} -ArgumentList $c

C:\PS> invoke-command -session $s -scriptblock {wait-job -any}

Beschreibung
-----------
In diesem Beispiel wird mit dem Any-Parameter von Wait-Job bestimmt, wann der erste einer Reihe von Hintergrundaufträgen abgeschlossen ist, die in der aktuellen Sitzung ausgeführt werden. Außerdem wird gezeigt, wie mit dem Cmdlet "Wait-Job" auf den Abschluss von Remoteaufträgen gewartet wird. 

Im ersten Befehl wird auf allen Computern, die in der Datei "Machines.txt" aufgeführt sind, eine PSSession erstellt und in der Variablen "$s" gespeichert. Der Befehl ruft mit dem Cmdlet "Get-Content" den Inhalt der Datei ab. Der Befehl "Get-Content" wird in Klammern eingeschlossen, um sicherzustellen, dass er vor dem Befehl "New-PSSession" ausgeführt wird.

Im zweiten Befehl wird eine Get-EventLog-Befehlszeichenfolge (in Anführungszeichen) in der Variablen "$c" gespeichert.

Im dritten Befehl wird der Befehl "Start-Job" in den einzelnen Sitzungen in $s mit dem Cmdlet "Invoke-Command" ausgeführt. Mit dem Befehl "Start-Job" wird ein Hintergrundauftrag gestartet, der den Befehl in $c ausführt. 

Da es sich bei $c um eine Variable auf dem lokalen Computer handelt, verwendet der Befehl das param-Schlüsselwort zur Deklaration der lokalen Variablen im Befehl und den ArgumentList-Parameter zur Angabe der Werte für diese Variablen.

Im vierten Befehl wird ein Wait-Job-Befehl in den Sitzungen mit dem Cmdlet "Invoke-Command" ausgeführt. Mit dem Cmdlet "Wait-Job" wird gewartet, bis der erste Auftrag auf den Remotecomputern abgeschlossen ist.

C:\PS>$s = new-pssession Server01, Server02, Server03 

C:\PS> $jobs = invoke-command -session $s -scriptblock {start-job -script {get-date}}

C:\PS> $done = invoke-command -session $s -scriptblock {wait-job -timeout 30}

Beschreibung
-----------
In diesem Beispiel wird gezeigt, wie mit dem Timeout-Parameter von Wait-Job eine maximale Wartezeit für Aufträge festgelegt wird, die auf Remotecomputern ausgeführt werden. 

Im ersten Befehl wird eine PSSession auf jedem der drei Remotecomputer "Server01", "Server02" und "Server03" erstellt, und die PSSessions werden in der Variablen "$s" gespeichert. 

Im zweiten Befehl wird der Befehl "Start-Job" in den einzelnen PSSessions in $s mit dem Cmdlet "Invoke-Command" ausgeführt. Die resultierenden Auftragsobjekte werden in der Variablen "$jobs" gespeichert.

Im dritten Befehl wird der Befehl "Wait-Job" in den einzelnen PSSessions in $s mit dem Cmdlet "Invoke-Command" ausgeführt. Mit dem Befehl "Wait-Job" wird bestimmt, ob alle Befehle innerhalb von 30 Sekunden abgeschlossen wurden. Der Befehl verwendet den Timeout-Parameter mit dem Wert 30 (Sekunden), um die maximale Wartezeit festzulegen und speichert die Ergebnisse des Befehls in der Variablen "$done". 

In diesem Fall wurde nach 30 Sekunden nur der Befehl auf dem Computer "Server02" abgeschlossen. Wait-Job beendet den Wartevorgang, zeigt die Eingabeaufforderung an und gibt das Objekt zurück, das den abgeschlossenen Auftrag darstellt. 

Die Variable "$done" enthält ein Auftragsobjekt, das den Auftrag darstellt, der auf Server02 ausgeführt wurde.

C:\PS>wait-job -id 1,2,5 -any

Beschreibung
-----------
Mit diesem Befehl werden drei Aufträge anhand der IDs identifiziert, und es wird gewartet, bis einer der Aufträge abgeschlossen wurde. Die Eingabeaufforderung wird zurückgegeben, wenn der erste Auftrag abgeschlossen wird.

C:\PS>wait-job -name DailyLog -timeout 120

Beschreibung
-----------
Dieser Befehl wartet 120 Sekunden (zwei Minuten) auf den Abschluss des Auftrags "DailyLog". Wenn der Auftrag in den folgenden zwei Minuten nicht abgeschlossen wird, wird die Eingabeaufforderung dennoch zurückgegeben, und der Auftrag wird weiterhin im Hintergrund ausgeführt.

C:\PS>wait-job -name Job3

Beschreibung
-----------
Mit diesem Wait-Job-Befehl wird der Auftrag, auf den gewartet werden soll, anhand des Namens identifiziert.

C:\PS>C:\PS> $j = start-job -script {get-childitem *.ps1| where {$_lastwritetime -gt ((get-date) - (new-timespan -days 7))}}

C:\PS> $j | wait-job

Beschreibung
-----------
In diesem Beispiel wird gezeigt, wie das Cmdlet "Wait-Job" unter Verwendung des Cmdlet "Start-Job" mit Aufträgen verwendet wird, die dem lokalen Computer gestartet wurden.

Mit diesen Befehlen wird ein Auftrag gestartet, um die Windows PowerShell-Skriptdateien abzurufen, die in der vergangenen Woche hinzugefügt oder aktualisiert wurden.

Im ersten Befehl wird mit dem Cmdlet "Start-Job" ein Hintergrundauftrag auf dem lokalen Computer gestartet. Im Auftrag wird ein Get-ChildItem-Befehl ausgeführt, mit dem alle Dateien mit der Dateinamenerweiterung ".ps1" abgerufen werden, die in der vergangenen Woche hinzugefügt oder aktualisiert wurden.

Im dritten Befehl wird mit dem Cmdlet "Wait-Job" gewartet, bis der Auftrag abgeschlossen wurde. Wenn der Auftrag abgeschlossen wird, wird das Auftragsobjekt vom Befehl angezeigt, das Informationen über den Auftrag enthält.

C:\PS>$s = new-pssession Server01, Server02, Server03

C:\PS> $j = invoke-command -session $s -scriptblock {get-process} -asjob

C:\PS> $j | wait-job

Beschreibung
-----------
In diesem Beispiel wird gezeigt, wie mit dem AsJob-Parameter des Cmdlet "Invoke-Command" das Cmdlet "Wait-Job" mit Aufträgen verwendet wird, die auf Remotecomputern gestartet wurden. Mit AsJob wird der Auftrag auf dem lokalen Computer erstellt, und die Ergebnisse werden automatisch an den lokalen Computer zurückgegeben, obwohl der Auftrag auf den Remotecomputern ausgeführt wird.

In diesem Beispiel wird mit Wait-Job bestimmt, ob die Ausführung des Befehls "Get-Process" in den Sitzungen auf drei Remotecomputern abgeschlossen wurde. 

Im ersten Befehl werden PSSessions auf drei Computern erstellt und in der Variablen "$s" gespeichert. 

Im zweiten Befehl wird mit dem Cmdlet "Invoke-Command" ein Get-Process-Befehl in jeder der drei PSSession in $s ausgeführt. Bei dem Befehl wird der Befehl asynchron mit dem AsJob-Parameter als Hintergrundauftrag ausgeführt. Analog zu den Aufträgen, die mit Start-Job gestartet wurden, wird vom Befehl ein Auftragsobjekt zurückgegeben, und das Objekt wird in der Variablen "$j" gespeichert.

Im dritten Befehl wird das Auftragsobjekt in $j mit einem Pipelineoperator (|) an das Cmdlet "Wait-Job" gesendet. In diesem Fall ist der Befehl "Invoke-Command" nicht erforderlich, da sich der Auftrag auf dem lokalen Computer befindet.

C:\PS>get-job

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

C:\PS> wait-job -id 1

Beschreibung
-----------
Dieser Befehl wartet auf den Auftrag mit dem ID-Wert 1.