Wait-Job

Modul:

Microsoft.PowerShell.Core

Unterdrückt die Eingabeaufforderung, bis einer oder alle der in der Sitzung ausgeführten Windows PowerShell Hintergrundaufträge abgeschlossen sind.

Syntax

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

Beschreibung

Das Cmdlet Wait-Job wartet, bis Windows PowerShell Hintergrundaufträge abgeschlossen sind, bevor die Eingabeaufforderung angezeigt wird. Sie können warten, bis ein Hintergrundauftrag abgeschlossen ist, oder bis alle Hintergrundaufträge abgeschlossen sind, und Sie können eine maximale Wartezeit für den Auftrag festlegen.

Wenn die Befehle im Auftrag abgeschlossen sind, zeigt Wait-Job die Eingabeaufforderung an und gibt ein Auftragsobjekt zurück, das Sie an einen anderen Befehl übergeben können.

Sie können das Cmdlet Wait-Job verwenden, um auf Hintergrundaufträge zu warten, z. B. solche, die mit dem Cmdlet Start-Job oder dem Parameter AsJob des Cmdlets Invoke-Command gestartet wurden. Weitere Informationen zu Windows PowerShell-Hintergrundaufträgen finden Sie unter about_Jobs.

Ab Windows PowerShell 3.0 wartet das Cmdlet Wait-Job auch auf benutzerdefinierte Auftragstypen, z. B. Workflowaufträge und Instanzen geplanter Aufträge. Damit Wait-Job auf Aufträge eines bestimmten Typs warten kann, importieren Sie das Modul, das den benutzerdefinierten Auftragstyp unterstützt, in die Sitzung, bevor Sie das Cmdlet Get-Job ausführen, indem Sie entweder das Cmdlet Import-Module verwenden oder ein Cmdlet im Modul verwenden oder abrufen. Informationen zu einem bestimmten benutzerdefinierten Auftragstyp finden Sie in der Dokumentation der Funktion „Benutzerdefinierte Auftragstypen“.

Beispiele

Beispiel 1: Warten auf alle Aufträge

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

Dieser Befehl wartet darauf, dass alle in der Sitzung ausgeführten Hintergrundaufträge abgeschlossen sind.

Beispiel 2: Warten auf Aufträge, die auf Remotecomputern mithilfe von 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 diesem Beispiel wird gezeigt, wie Sie das Cmdlet Wait-Job mit Aufträgen verwenden, die auf Remotecomputern mithilfe des Cmdlets Start-Job gestartet wurden. Sowohl Start-Job - als auch Wait-Job-Befehle werden mithilfe des Invoke-Command-Cmdlets an den Remotecomputer übermittelt.

In diesem Beispiel wird wait-Job verwendet, um zu bestimmen, ob ein Get-Date Befehl, der als Hintergrundauftrag auf drei verschiedenen Computern ausgeführt wird, abgeschlossen ist.

Der erste Befehl erstellt eine Windows PowerShell-Sitzung (PSSession) auf jedem der drei Remotecomputer und speichert sie in der variablen $s.

Der zweite Befehl verwendet Invoke-Command , um Start-Job in jeder der drei Sitzungen in $s auszuführen. Alle Aufträge haben den Namen Date1.

Der dritte Befehl verwendet Invoke-Command , um Wait-Job auszuführen. Dieser Befehl wartet auf den Abschluss der Date1-Aufträge auf jedem Computer. Die resultierende Auflistung (Array) der Auftragsobjekte wird in der $done-Variablen gespeichert.

Der vierte Befehl verwendet die Count-Eigenschaft des Arrays von Auftragsobjekten in der variablen $done, um zu bestimmen, wie viele der Aufträge abgeschlossen sind.

Beispiel 3: Bestimmen, wann der erste Hintergrundauftrag abgeschlossen ist

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 diesem Beispiel wird der Any-Parameter von Wait-Job verwendet, um zu bestimmen, wann der erste von vielen Hintergrundaufträgen, die in der aktuellen Sitzung ausgeführt werden, abgeschlossen wird. Außerdem wird gezeigt, wie Sie mit dem Cmdlet Wait-Job auf den Abschluss von Remoteaufträgen warten.

Der erste Befehl erstellt eine PSSession auf jedem der in der Machines.txt-Datei aufgeführten Computer und speichert die PSSession-Objekte in der variablen $s. Der Befehl verwendet das Cmdlet Get-Content, um den Inhalt der Datei abzurufen. Der Befehl Get-Content wird in Klammern eingeschlossen, um sicherzustellen, dass er vor dem Befehl New-PSSession ausgeführt wird.

Der zweite Befehl speichert eine Get-EventLog-Befehlszeichenfolge in Anführungszeichen in der variablen $c.

Der dritte Befehl verwendet Invoke-Command Cmdlet, um Start-Job in jeder der Sitzungen in $s auszuführen. Der Befehl Start-Job startet einen Hintergrundauftrag, der den Befehl Get-EventLog in der variablen $c ausführt.

Der Befehl verwendet den Using-Bereichsbezeichner, um anzugeben, dass die $c-Variable auf dem lokalen Computer definiert wurde. Der Using-Bereichsbezeichner wurde in Windows PowerShell 3.0 eingeführt. Weitere Informationen zum Verwenden des Bereichsmodifizierers finden Sie unter about_Remote_Variables (https://go.microsoft.com/fwlink/?LinkID=252653).

Der vierte Befehl verwendet Invoke-Command , um einen Wait-Job-Befehl in den Sitzungen auszuführen. Der Parameter Any wird verwendet, um zu warten, bis der erste Auftrag auf den Remotecomputern abgeschlossen ist.

Beispiel 4: Festlegen einer Wartezeit für Aufträge auf Remotecomputern

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 diesem Beispiel wird gezeigt, wie der Timeout-Parameter von Wait-Job verwendet wird, um eine maximale Wartezeit für die Aufträge festzulegen, die auf Remotecomputern ausgeführt werden.

Der erste Befehl erstellt eine PSSession auf jedem der drei Remotecomputer (Server01, Server02 und Server03) und speichert dann die PSSession-Objekte in der variablen $s.

Der zweite Befehl verwendet Invoke-Command , um Start-Job in jedem psSession-Objekt in $s auszuführen. Die resultierenden Auftragsobjekte werden in der variablen $jobs gespeichert.

Der dritte Befehl verwendet Invoke-Command , um Wait-Job in jeder der Sitzungen in $s auszuführen. Der Befehl Wait-Job bestimmt, ob alle Befehle innerhalb von 30 Sekunden abgeschlossen wurden. Es verwendet den Timeout-Parameter mit dem Wert 30, um die maximale Wartezeit festzulegen, und speichert dann die Ergebnisse des Befehls in der variablen $done.

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

Die $done-Variable enthält ein Auftragsobjekt, das den auf Server02 ausgeführten Auftrag darstellt.

Beispiel 5: Warten, bis einer von mehreren Aufträgen abgeschlossen ist

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

Dieser Befehl identifiziert drei Aufträge anhand ihrer IDs und wartet, bis eine davon abgeschlossen ist. Die Eingabeaufforderung gibt zurück, wenn der erste Auftrag abgeschlossen ist.

Beispiel 6: Warten Sie auf einen Bestimmten Zeitraum, und lassen Sie dann zu, dass der Auftrag im Hintergrund fortgesetzt wird.

PS C:\> Wait-Job -Name "DailyLog" -Timeout 120

Dieser Befehl wartet 120 Sekunden (zwei Minuten), bis der DailyLog-Auftrag abgeschlossen ist. Wenn der Auftrag in den nächsten zwei Minuten nicht abgeschlossen wird, wird die Eingabeaufforderung trotzdem zurückgegeben, und der Auftrag wird weiterhin im Hintergrund ausgeführt.

Beispiel 7: Warten auf einen Auftrag anhand des Namens

PS C:\> Wait-Job -Name "Job3"

Dieser Befehl verwendet den Auftragsnamen, um den Auftrag zu identifizieren, auf den gewartet werden soll.

Beispiel 8: Warten auf Aufträge auf dem lokalen Computer, die mit 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 diesem Beispiel wird gezeigt, wie Sie das Cmdlet Wait-Job mit Aufträgen verwenden, die auf dem lokalen Computer mithilfe von Start-Job gestartet wurden.

Diese Befehle starten einen Auftrag, der die Windows PowerShell-Skriptdateien abruft, die in der letzten Woche hinzugefügt oder aktualisiert wurden.

Der erste Befehl verwendet Start-Job , um einen Hintergrundauftrag auf dem lokalen Computer zu starten. Der Auftrag führt einen Get-ChildItem-Befehl aus, der alle Dateien mit einer .ps1 Dateinamenerweiterung abruft, die in der letzten Woche hinzugefügt oder aktualisiert wurden.

Der dritte Befehl verwendet Wait-Job , um zu warten, bis der Auftrag abgeschlossen ist. Nach Abschluss des Auftrags zeigt der Befehl das Auftragsobjekt an, das Informationen zum Auftrag enthält.

Beispiel 9: Warten auf Aufträge, die auf Remotecomputern mithilfe von 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 diesem Beispiel wird gezeigt, wie Wait-Job mit Aufträgen verwendet wird, die auf Remotecomputern mithilfe des AsJob-Parameters von Invoke-Command gestartet werden. Bei Verwendung von 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 wait-Job verwendet, um zu bestimmen, ob ein Get-Process-Befehl abgeschlossen wird, der in den Sitzungen auf drei Remotecomputern ausgeführt wird.

Der erste Befehl erstellt PSSession-Objekte auf drei Computern und speichert sie in der variablen $s.

Der zweite Befehl verwendet Invoke-Command , um Get-Process in jeder der drei Sitzungen in $s auszuführen. Der Befehl verwendet den AsJob-Parameter , um den Befehl asynchron als Hintergrundauftrag auszuführen. Der Befehl gibt ein Auftragsobjekt zurück, genau wie die Aufträge, die mit Start-Job gestartet wurden, und das Auftragsobjekt wird in der variablen $j gespeichert.

Der dritte Befehl verwendet einen Pipelineoperator (|), um das Auftragsobjekt in $j an das Cmdlet Wait-Job zu senden. In diesem Fall ist kein Invoke-Command-Befehl erforderlich, da sich der Auftrag auf dem lokalen Computer befindet.

Beispiel 10: Warten auf einen Auftrag mit einer 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

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

Parameter

-Any

Gibt an, dass dieses Cmdlet die Eingabeaufforderung anzeigt und das Auftragsobjekt zurückgibt, wenn ein Auftrag abgeschlossen ist. Standardmäßig wartet Wait-Job , bis alle angegebenen Aufträge abgeschlossen sind, bevor die Eingabeaufforderung angezeigt wird.

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

-Filter

Gibt eine Hashtabelle mit Bedingungen an. Dieses Cmdlet wartet auf Aufträge, die alle Bedingungen in der Hashtabelle erfüllen. Geben Sie eine Hashtabelle ein, in der die Schlüssel Auftragseigenschaften und die Werte Werte der Auftragseigenschaften sind.

Dieser Parameter funktioniert nur mit benutzerdefinierten Auftragstypen, z. B. Workflowaufträgen und geplanten Aufträgen. Sie funktioniert nicht für Standard-Hintergrundaufträge, z. B. solche, die mit dem Cmdlet Start-Job erstellt wurden. Weitere Informationen zur Unterstützung für diesen Parameter finden Sie unter dem Hilfethema für den Auftragstyp.

Dieser Parameter wurde in Windows PowerShell 3.0 eingeführt.

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

-Force

Gibt an, dass dieses Cmdlet weiterhin auf Aufträge im Zustand Angehalten oder Getrennt wartet. Standardmäßig gibt Wait-Job die Wartezeit zurück oder beendet sie, wenn sich Aufträge in einem der folgenden Zustände befinden:

• Abgeschlossen
• Fehler
• Beendet
• Ausgesetzt
• Getrennt

Dieser Parameter wurde in Windows PowerShell 3.0 eingeführt.

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

-Id

Gibt ein Array von IDs von Aufträgen an, auf die dieses Cmdlet wartet.

Die ID ist eine ganze Zahl, die den Auftrag in der aktuellen Sitzung eindeutig identifiziert. Es ist einfacher zu merken und einzugeben als die instance-ID, aber sie ist nur in der aktuellen Sitzung eindeutig. Sie können eine oder mehrere IDs durch Kommas getrennt eingeben. Um die ID eines Auftrags zu ermitteln, geben Sie ein Get-Job.

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

-InstanceId

Gibt ein Array von instance IDs von Aufträgen an, auf die dieses Cmdlet wartet. Standardmäßig werden alle Aufträge fortgesetzt.

Eine Instanz-ID ist eine GUID, die den Auftrag auf dem Computer eindeutig identifiziert. Zum Ermitteln der Instanz-ID eines Auftrags verwenden Sie Get-Job.

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

-Job

Gibt die Aufträge an, auf die dieses Cmdlet wartet. Geben Sie eine Variable ein, die Auftragsobjekte bzw. einen Befehl enthält, der die Auftragsobjekte abruft. Sie können auch einen Pipelineoperator verwenden, um Auftragsobjekte an das Cmdlet Wait-Job zu senden. Standardmäßig wartet Wait-Job auf alle Aufträge, die in der aktuellen Sitzung erstellt wurden.

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

-Name

Gibt Anzeigenamen von Aufträgen an, auf die dieses Cmdlet wartet.

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

-State

Gibt einen Auftragsstatus an. Dieses Cmdlet wartet nur auf Aufträge im angegebenen Zustand. Zulässige Werte für diesen Parameter:

• NotStarted
• Wird ausgeführt
• Abgeschlossen
• Fehler
• Beendet
• Blockiert
• Ausgesetzt
• Getrennt
• Wird angehalten
• Wird beendet

Weitere Informationen zu Auftragszuständen finden Sie unter JobState Enumeration in der MSDN Library.

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

Gibt die maximale Wartezeit für jeden Hintergrundauftrag in Sekunden an. Der Standardwert -1 gibt an, dass das Cmdlet wartet, bis der Auftrag abgeschlossen ist. Das Timing beginnt, wenn Sie den Befehl Wait-Job und nicht den Befehl Start-Job übermitteln.

Wenn diese Zeit abgelaufen ist, endet der Wartevorgang, und die Befehlseingabeaufforderung wird wieder angezeigt, auch wenn der Auftrag noch läuft. Der Befehl zeigt keine Fehlermeldung an.

Type:	Int32
Aliases:	TimeoutSec
Position:	Named
Default value:	None
Required:	False
Accept pipeline input:	False
Accept wildcard characters:	False

Eingaben

System.Management.Automation.RemotingJob

Sie können ein Auftragsobjekt an dieses Cmdlet übergeben.

Ausgaben

System.Management.Automation.PSRemotingJob

Dieses Cmdlet gibt Auftragsobjekte zurück, die die abgeschlossenen Aufträge darstellen. Wenn die Wartezeit endet, weil der Wert des Timeout-Parameters überschritten wird, gibt Wait-Job keine -Objekte zurück.

Hinweise

• Standardmäßig gibt Wait-Job die Wartezeit zurück oder beendet sie, wenn sich Aufträge in einem der folgenden Zustände befinden:

• Abgeschlossen
• Fehler
• Beendet
• Ausgesetzt
• Getrennt Verwenden Sie den Force-Parameter, um Wait-Job weiter auf angehaltene und getrennte Aufträge zu warten.

Ähnliche Themen

• 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