about_Jobs
Letzte Aktualisierung: Mai 2014
Betrifft: Windows PowerShell 2.0, Windows PowerShell 3.0, Windows PowerShell 4.0, Windows PowerShell 5.0
THEMA
about_Jobs
KURZE BESCHREIBUNG
Enthält Informationen darüber, wie Windows PowerShell-Hintergrundaufträge einen Befehl oder einen Ausdruck im Hintergrund ausführen, ohne mit der aktuellen Sitzung zu interagieren.
LANGE BESCHREIBUNG
In diesem Thema wird erläutert, wie Hintergrundaufträge in Windows PowerShell auf einem lokalen Computer ausgeführt werden. Informationen zum Ausführen von Hintergrundaufträgen auf Remote-Computern finden Sie unter „about_Remote_Jobs“.
Wenn Sie einen Hintergrundauftrag starten, erfolgt die sofortige Rückkehr zur Befehlszeile, selbst wenn der Abschluss eines Auftrags längere Zeit in Anspruch nimmt. Sie können ohne Unterbrechung in der Sitzung weiterarbeiten, während der Auftrag abgeschlossen wird.
DIE JOB-CMDLETS
Start-Job
Startet einen Hintergrundauftrag auf einem lokalen Computer.
Get-Job
Ruft die Hintergrundaufträge ab, die in der aktuellen Sitzung gestartet wurden.
Receive-Job
Ruft die Ergebnisse der Hintergrundaufträge ab.
Stop-Job
Stoppt einen Hintergrundauftrag.
Wait-Job
Unterdrückt die Befehlszeile an, bis ein oder alle Aufträge abgeschlossen sind.
Remove-Job
Löscht einen Hintergrundauftrag.
Invoke-Command
Der AsJob-Parameter führt jeden Befehl als Hintergrundauftrag auf einem Remote-Computer aus. Sie können auch Invoke-Command zur Remote-Ausführung jedes Auftragsbefehls verwenden, was auch für einen Start-Job-Befehl gilt.
STARTEN EINES AUFTRAGS AUF DEM LOKALEN COMPUTER
Um einen Hintergrundauftrag auf dem lokalen Computer zu starten, verwenden Sie das Start-Job-Cmdlet.
Zum Schreiben eines Start-Job-Befehls schließen Sie den Befehl, den der Auftrag ausführen, soll in geschweifte Klammern ( {} ) ein. Verwenden Sie den SriptBlock-Parameter zur Angabe des Befehls.
Mit folgendem Befehl wird ein Hintergrundauftrag gestartet, der einen Get-Process-Befehl auf dem lokalen Computer ausführt.
Start-Job -ScriptBlock {Get-Process}
Der Start-Job-Befehl gibt ein Objekt zurück, das den Auftrag repräsentiert. Das Auftragsobjekt enthält nützliche Informationen zum Auftrag, aber keine Auftragsergebnisse.
Speichern Sie das Job-Objekt in einer Variablen, und verwenden Sie diese dann mit den anderen Job-Cmdlets zum Verwalten des Hintergrundauftrags. Der folgende Befehl startet ein Auftragsobjekt und speichert das resultierende Auftragsobjekt in der $job-Variablen.
$job = Start-Job -ScriptBlock {Get-Process}
Sie können auch das Get-Job-Cmdlet verwenden, um Objekte abzurufen, welche die in der aktuellen Sitzung gestarteten Aufträge repräsentieren. Get-Job gibt dasselbe Auftragsobjekt zurück wie Start-Job.
ABRUFEN VON AUFTRAGSOBJEKTEN
Verwenden Sie das Get-Job-Cmdlet, um die Objekte abzurufen, die die Hintergrundaufträge repräsentieren, die in der aktuellen Sitzung gestartet wurden. Ohne Parameter gibt Get-Job alle Aufträge zurück, die in der aktuellen Sitzung gestartet wurden.
Beispielsweise ruft der folgende Befehl die Aufträge in der aktuellen Sitzung ab.
PS C:\>Get-Job
Id Name PSJobTypeName State HasMoreData Location Command
-- ---- ------------- ----- ----------- -------- -------
1 Job1 BackgroundJob Running True localhost Get-Process
Sie können auch das Auftragsobjekt in einer Variablen speichern und diese verwenden, um in einem späteren Befehl den Auftrag zu repräsentieren. Der folgende Befehl ruft den Auftrag mit der ID 1 ab und speichert ihn in der $job-Variablen.
$job = Get-Job -Id 1
Das Auftragsobjekt enthält den Status des Auftrags, der angibt, ob der Auftrag abgeschlossen ist. Ein abgeschlossener Auftrag hat den Status „Complete“ (Abgeschlossen) oder „Failed“ (Fehlgeschlagen). Ein Auftrag kann auch blockiert sein oder noch ausgeführt werden.
Get-Job
Id Name PSJobTypeName State HasMoreData Location Command
-- ---- ------------- ----- ----------- -------- -------
1 Job1 BackgroundJob Complete True localhost Get-Process
ABRUFEN DER ERGEBNISSE EINES AUFTRAGS
Wenn Sie einen Hintergrundauftrag ausführen, werden die Ergebnisse nicht unmittelbar angezeigt. Stattdessen gibt das Start-Job-Cmdlet ein Auftragsobjekt zurück, das den Auftrag repräsentiert, jedoch nicht die Ergebnisse enthält. Um die Ergebnisse eines Hintergrundauftrags abzurufen, verwenden Sie das Receive-Job-Cmdlet.
Im folgenden Befehl wird das Receive-Job-Cmdlet zum Abrufen der Ergebnisse des Auftrags verwendet. Er verwendet ein Auftragsobjekt, das in der $job-Variablen gespeichert ist, um den Auftrag zu identifizieren.
Receive-Job -Job $job
Das Receive-Job-Cmdlet gibt die Ergebnisse des Auftrags zurück.
Handles NPM(K) PM(K) WS(K) VM(M) CPU(s) Id ProcessName
------- ------ ----- ----- ----- ------ -- -----------
103 4 11328 9692 56 1176 audiodg
804 14 12228 14108 100 101.74 1740 CcmExec
668 7 2672 6168 104 32.26 488 csrss
...
Sie können auch die Ergebnisse eines Auftrags in einer Variablen speichern. Der folgende Befehl speichert die Ergebnisse des Auftrags aus der $job-Variablen in der $results-Variablen.
$results = Receive-Job -Job $job
Und Sie können die Ergebnisse des Auftrags in einer Datei speichern, indem sie den Umleitungsoperator (>) oder das Out-File-Cmdlet verwenden. Der folgende Befehl verwendet den Umleitungsoperator, um die Ergebnisse des Auftrags in $job-Variablen in der Datei „Results.txt“ zu speichern.
Receive-Job -Job $job > results.txt
ABRUFEN UND BEHALTEN VON TEILWEISEN AUFTRAGSERGEBNISSEN
Das Receive-Job-Cmdlet ruft die Ergebnisse eines Hintergrundauftrags ab. Wenn der Auftrag abgeschlossen ist, ruft Receive-Job alle Auftragsergebnisse ab. Wenn der Auftrag noch ausgeführt wird, ruft Receive-Job die Ergebnisse ab, die bisher generiert wurden. Sie können die Receive-Befehle erneut ausführen, um die verbleibenden Ergebnisse abzurufen.
Wenn Receive-Job Ergebnisse zurückgibt, werden diese Ergebnisse standardmäßig aus dem Cache gelöscht, wo die Auftragsergebnisse gespeichert werden. Wenn Sie einen anderen Receive-Job-Befehl ausführen, erhalten Sie nur die Ergebnisse, die noch nicht empfangen wurden.
Die folgenden Befehle zeigen die Ergebnisse von Receive-Befehlen, die ausgeführt wurden, bevor der Auftrag abgeschlossen ist.
C:\PS> Receive-Job -Job $job
Handles NPM(K) PM(K) WS(K) VM(M) CPU(s) Id ProcessName
------- ------ ----- ----- ----- ------ -- -----------
103 4 11328 9692 56 1176 audiodg
804 14 12228 14108 100 101.74 1740 CcmExec
C:\PS> Receive-Job -Job $job
Handles NPM(K) PM(K) WS(K) VM(M) CPU(s) Id ProcessName
------- ------ ----- ----- ----- ------ -- -----------
68 3 2632 664 29 0.36 1388 ccmsetup
749 22 21468 19940 203 122.13 3644 communicator
905 7 2980 2628 34 197.97 424 csrss
1121 25 28408 32940 174 430.14 3048 explorer
Verwenden Sie den Keep-Parameter, um zu verhindern, dass Receive-Job die Ergebnisse löscht, die es bereits zurückgegeben hat. Das bewirkt, dass Receive-Job alle Ergebnisse zurückgibt, die bis zu diesem Zeitpunkt generiert wurden.
Die folgenden Befehle zeigen die Auswirkung der Verwendung des Keep-Parameters auf einen Auftrag, der noch nicht abgeschlossen ist.
C:\PS> Receive-Job -Job $job -Keep
Handles NPM(K) PM(K) WS(K) VM(M) CPU(s) Id ProcessName
------- ------ ----- ----- ----- ------ -- -----------
103 4 11328 9692 56 1176 audiodg
804 14 12228 14108 100 101.74 1740 CcmExec
C:\PS> Receive-Job -Job $job -Keep
Handles NPM(K) PM(K) WS(K) VM(M) CPU(s) Id ProcessName
------- ------ ----- ----- ----- ------ -- -----------
103 4 11328 9692 56 1176 audiodg
804 14 12228 14108 100 101.74 1740 CcmExec
68 3 2632 664 29 0.36 1388 ccmsetup
749 22 21468 19940 203 122.13 3644 communicator
905 7 2980 2628 34 197.97 424 csrss
1121 25 28408 32940 174 430.14 3048 explorer
WARTEN AUF DIE ERGEBNISSE
Wenn Sie einen Befehl ausführen, dessen Abschluss lange Zeit in Anspruch nimmt, können Sie anhand der Eigenschaften des Auftragsobjekts bestimmen, wann der Auftrag abgeschlossen ist. Der folgende Befehl verwendet das Get-Job-Objekt, um alle Hintergrundaufträge in der aktuellen Sitzung abzurufen.
Get-Job
Die Ergebnisse werden in einer Tabelle angezeigt. Der Status des Auftrags wird in der State-Spalte (Status) angezeigt.
Id Name PSJobTypeName State HasMoreData Location Command
-- ---- ------------- ----- ----------- -------- -------
1 Job1 BackgroundJob Complete True localhost Get-Process
2 Job2 BackgroundJob Running True localhost Get-EventLog -Log Syst...
3 Job3 BackgroundJob Complete True localhost dir -Path C:\* -Recurse
In diesem Fall zeigt die State-Eigenschaft, dass der Auftrag 2 noch ausgeführt wird. Würden Sie das Receive-Job-Cmdlet verwenden, um jetzt die Auftragsergebnisse abzurufen, wären die Ergebnisse unvollständig. Sie können das Receive-Job-Cmdlet wiederholt verwenden, um alle Ergebnisse zu erhalten. Standardmäßig erhalten Sie bei jeder Verwendung nur die Ergebnisse, die nicht bereits empfangen wurden, aber Sie können den Keep-Parameter des Receive-Job-Cmdlets nutzen, um die Ergebnisse beizubehalten, selbst wenn sie bereits empfangen wurden.
Sie können die Teilergebnisse in eine Datei schreiben und dann neuere Ergebnisse bei ihrem Empfang anhängen. Oder Sie können warten und den Status des Auftrags später überprüfen.
Sie können den Wait-Parameter des Receive-Job-Cmdlets verwenden, der erst die Befehlszeile liefert, wenn der Auftrag abgeschlossen ist und alle Ergebnisse verfügbar sind.
Sie können auch das Wait-Job-Cmdlet verwenden, um auf einige oder alle Ergebnisse des Auftrags zu warten. Mit Wait-Job können auf einen bestimmten Auftrag, auf alle Aufträge oder auf die abzuschließenden Aufträge warten.
Der folgende Befehl verwendet das Wait-Job-Cmdlet, um auf einen Auftrag mit der ID 10 zu warten.
Wait-Job -ID 10
Dies hat zur Folge, dass die Windows PowerShell-Befehlszeile unterdrückt wird, bis der Auftrag abgeschlossen ist.
Sie können auch für einen festgelegten Zeitraum warten. Mit diesem Befehl wird mit dem Timeout-Parameter die Wartezeit auf 120 Sekunden beschränkt. Wenn die Zeit abgelaufen ist, wird die Befehlszeile ausgegeben, aber der Auftrag wird weiterhin im Hintergrund ausgeführt.
Wait-Job -ID 10 -Timeout 120
STOPPEN EINES AUFTRAGS
Zum Stoppen eines Hintergrundauftrags verwenden Sie das Stop-Job-Cmdlet. Der folgende Befehl startet einen Auftrag zum Abrufen von jedem Eintrag im System-Ereignisprotokoll. Er speichert das Auftragsobjekt in der $job-Variablen.
$job = Start-Job -ScriptBlock {Get-EventLog -Log System}
Der folgende Befehl stoppt den Auftrag. Dazu wird ein Pipeline-Operator (|) verwendet, um den Auftrag in der $job-Variablen an „Stop-Job“ zu senden.
$job | Stop-Job
LÖSCHEN EINES AUFTRAGS
Zum Löschen eines Hintergrundauftrags verwenden Sie das Remove-Job-Cmdlet. Der folgende Befehl löscht den Auftrag in der $job-Variablen.
Remove-Job -Job $job
UNTERSUCHEN EINEN FEHLGESCHLAGENEN AUFTRAGS
Um herauszufinden, warum ein Auftrag fehlgeschlagen ist, verwenden Sie die Reason-Untereigenschaften des Job-Objekts.
Der folgende Befehl startet einen Auftrag ohne die erforderlichen Anmeldeinformationen. Er speichert das Auftragsobjekt in der $job-Variablen.
$job = Start-Job -ScriptBlock {New-Item -Path HKLM:\Software\MyCompany}
Id Name PSJobTypeName State HasMoreData Location Command
-- ---- ------------- ----- ----------- -------- -------
1 Job1 BackgroundJob Failed False localhost New-Item -Path HKLM:\S...
Der folgende Befehl verwendet die Reason-Eigenschaft, um den Fehler festzustellen, der zum Fehlschlagen des Auftrags geführt hat.
$job.ChildJobs[0].JobStateInfo.Reason
In diesem Fall ist der Auftrag fehlgeschlagen, weil der Remote-Computer explizite Anmeldeinformationen zum Ausführen des Befehls erforderte. Der Wert der Reason-Eigenschaft ist:
Connecting to remote server failed with the following error
message : Access is denied.
SIEHE AUCH
about_Remote_Jobs
about_Job_Details
about_Remote
about_PSSessions
Start-Job
Get-Job
Receive-Job
Stop-Job
Wait-Job
Remove-Job
Invoke-Command