about_Jobs

Kurzbeschreibung

Enthält Informationen dazu, wie PowerShell-Hintergrundaufträge einen Befehl oder Ausdruck im Hintergrund ausführen, ohne mit der aktuellen Sitzung zu interagieren.

Lange Beschreibung

PowerShell führt Befehle und Skripts gleichzeitig über Aufträge aus. Es gibt drei Auftragstypen, die von PowerShell bereitgestellt werden, um Parallelität zu unterstützen.

• RemoteJob – Befehle und Skripts werden in einer Remotesitzung ausgeführt. Informationen hierzu finden Sie unter about_Remote_Jobs.
• BackgroundJob – Befehle und Skripts werden in einem separaten Prozess auf dem lokalen Computer ausgeführt.
• PSTaskJob oder ThreadJob – Befehle und Skripts werden in einem separaten Thread innerhalb desselben Prozesses auf dem lokalen Computer ausgeführt. Weitere Informationen finden Sie unter about_Thread_Jobs.

Das Remote ausführen von Skripts, auf einem separaten Computer oder in einem separaten Prozess, bietet eine hervorragende Isolierung. Alle Fehler, die im Remoteauftrag auftreten, wirken sich nicht auf andere ausgeführte Aufträge oder die übergeordnete Sitzung aus, die den Auftrag gestartet hat. Die Remotingschicht erhöht jedoch den Aufwand, einschließlich objekt serialisieren. Alle Objekte werden serialisiert und deserialisiert, während sie zwischen der übergeordneten Sitzung und der Remotesitzung (Auftrag) übergeben werden. Die Serialisierung großer komplexer Datenobjekte kann große Mengen an Rechen- und Speicherressourcen verbrauchen und große Datenmengen über das Netzwerk übertragen.

Threadbasierte Aufträge sind nicht so robust wie Remote- und Hintergrundaufträge, da sie im selben Prozess in verschiedenen Threads ausgeführt werden. Wenn ein Auftrag einen kritischen Fehler aufweist, der den Prozess abstürzt, werden alle anderen Aufträge im Prozess beendet.

Jedoch erfordern thread-basierte Aufgaben weniger Aufwand. Sie verwenden nicht den Remoting-Layer oder die Serialisierung. Die Ergebnisobjekte werden als Verweise auf Liveobjekte in der aktuellen Sitzung zurückgegeben. Ohne diesen Aufwand werden threadbasierte Aufträge schneller ausgeführt und verwenden weniger Ressourcen als die anderen Auftragstypen.

Es gibt zwei Möglichkeiten, diese Situation zu umgehen:

1. Verwenden Sie Invoke-Command, um Aufträge zu erstellen, die in getrennten Sitzungen ausgeführt werden. Weitere Informationen finden Sie unter about_Remote_Jobs.
2. Verwenden Sie Start-Process, um einen neuen Prozess anstelle eines Auftrags zu erstellen. Weitere Informationen finden Sie unter Start-Process.

Die Auftrags-Cmdlets

So starten Sie einen Auftrag auf dem lokalen Computer

Verwenden Sie das Cmdlet Start-Job, um einen Hintergrundauftrag auf dem lokalen Computer zu starten.

Um einen Start-Job-Befehl zu schreiben, schließen Sie den Befehl ein, den der Auftrag in geschweiften geschweiften Klammern ({}) ausführt. Verwenden Sie den ScriptBlock Parameter, um den Befehl anzugeben.

Der folgende Befehl startet einen Hintergrundauftrag, der einen Get-Process Befehl auf dem lokalen Computer ausführt.

Start-Job -ScriptBlock {Get-Process}

Wenn Sie einen Hintergrundauftrag starten, wird die Eingabeaufforderung sofort zurückgegeben, auch wenn der Auftrag eine längere Zeit für den Abschluss benötigt. Sie können weiterhin in der Sitzung ohne Unterbrechung arbeiten, während der Auftrag ausgeführt wird.

Der Befehl Start-Job gibt ein Objekt zurück, das den Auftrag darstellt. Das Auftragsobjekt enthält nützliche Informationen über den Auftrag, aber nicht die Auftragsergebnisse.

Sie können das Auftragsobjekt in einer Variablen speichern und dann mit den anderen Job Cmdlets verwenden, um den Hintergrundauftrag zu verwalten. Der folgende Befehl startet ein Auftragsobjekt und speichert das resultierende Auftragsobjekt in der $job Variablen.

$job = Start-Job -ScriptBlock {Get-Process}

Ab PowerShell 6.0 können Sie den Hintergrundoperator (&) am Ende einer Pipeline verwenden, um einen Hintergrundauftrag zu starten. Weitere Informationen finden Sie unter Hintergrundoperator.

Die Verwendung des Hintergrundoperators entspricht funktionell der Verwendung des Cmdlets Start-Job im vorherigen Beispiel.

$job = Get-Process &

Abrufen von Auftragsobjekten

Das Cmdlet Get-Job gibt Objekte zurück, die die Hintergrundaufträge darstellen, die in der aktuellen Sitzung gestartet wurden. Ohne Parameter gibt Get-Job alle Aufträge zurück, die in der aktuellen Sitzung gestartet wurden.

Get-Job

Das Auftragsobjekt enthält den Status des Auftrags, der angibt, ob der Auftrag abgeschlossen ist. Ein fertiger Auftrag weist den Status Abgeschlossen oder fehlgeschlagenenauf. Ein Auftrag kann auch Blockierte oder Ausführen vonsein.

Id  Name  PSJobTypeName State      HasMoreData  Location   Command
--  ----  ------------- -----      -----------  --------   -------
1   Job1  BackgroundJob Complete   True         localhost  Get-Process

Sie können das Auftragsobjekt in einer Variablen speichern und ihn verwenden, um den Auftrag in einem späteren Befehl darzustellen. Der folgende Befehl ruft den Auftrag mit ID 1 ab und speichert ihn in der $job Variablen.

$job = Get-Job -Id 1

Abrufen der Ergebnisse eines Auftrags

Wenn Sie einen Hintergrundauftrag ausführen, werden die Ergebnisse nicht sofort angezeigt. Verwenden Sie das Cmdlet Receive-Job, um die Ergebnisse eines Hintergrundauftrags abzurufen.

Im folgenden Beispiel ruft das cmdlet Receive-Job die Ergebnisse des Auftrags mithilfe des Auftragsobjekts in der variablen $job ab.

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
    668       7     2672       6168   104    32.26   488 csrss
...

Sie können die Ergebnisse eines Auftrags in einer Variablen speichern. Mit dem folgenden Befehl werden die Ergebnisse des Auftrags in der variablen $job in der variablen $results gespeichert.

$results = Receive-Job -Job $job

Abrufen und Beibehalten von Teilauftragsergebnissen

Das Cmdlet Receive-Job ruft die Ergebnisse eines Hintergrundauftrags ab. Wenn der Auftrag abgeschlossen ist, erhält Receive-Job alle Auftragsergebnisse. Wenn der Auftrag noch ausgeführt wird, erhält Receive-Job die bisher generierten Ergebnisse. Sie können Receive-Job Befehle erneut ausführen, um die verbleibenden Ergebnisse zu erhalten.

Standardmäßig löscht Receive-Job die Ergebnisse aus dem Cache, in dem Auftragsergebnisse gespeichert werden. Wenn Sie Receive-Job erneut ausführen, erhalten Sie nur die neuen Ergebnisse, die nach der ersten Ausführung eintreffen.

In den folgenden Befehlen werden die Ergebnisse Receive-Job Ausgeführten Befehle angezeigt, 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 Parameter Keep, um zu verhindern, dass Receive-Job die zurückgegebenen Auftragsergebnisse löschen. Die folgenden Befehle zeigen, wie sich die Verwendung des Parameters "Keep" auf einen Auftrag auswirkt, 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, der eine lange Zeit dauert, können Sie die Eigenschaften des Auftragsobjekts verwenden, um zu 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 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 ...
3  Job3  BackgroundJob Complete True        localhost dir -Path C:\* -Re...

In diesem Fall zeigt die eigenschaft State an, dass Auftrag 2 noch ausgeführt wird. Wenn Sie das Cmdlet Receive-Job verwenden würden, um die Auftragsergebnisse jetzt abzurufen, wären die Ergebnisse unvollständig. Sie können das Cmdlet Receive-Job wiederholt verwenden, um alle Ergebnisse abzurufen. Verwenden Sie die eigenschaft State, um zu bestimmen, wann der Auftrag abgeschlossen ist.

Sie können auch den Parameter Wait des Cmdlets Receive-Job verwenden. Wenn Sie diesen Parameter verwenden, gibt das Cmdlet die Eingabeaufforderung erst zurück, wenn der Auftrag abgeschlossen ist und alle Ergebnisse verfügbar sind.

Sie können auch das Cmdlet Wait-Job verwenden, um auf ein oder alle Ergebnisse des Auftrags zu warten. mit Wait-Job können Sie auf einen oder mehrere bestimmte Aufträge oder auf alle Aufträge warten. Der folgende Befehl verwendet das Cmdlet Wait-Job, um auf einen Auftrag mit ID 10 zu warten.

Wait-Job -ID 10

Daher wird die PowerShell-Eingabeaufforderung unterdrückt, bis der Auftrag abgeschlossen ist.

Sie können auch auf einen vordefinierten Zeitraum warten. Dieser Befehl verwendet den Timeout Parameter, um die Wartezeit auf 120 Sekunden zu begrenzen. Wenn die Zeit abläuft, gibt die Eingabeaufforderung zurück, aber der Auftrag wird weiterhin im Hintergrund ausgeführt.

Wait-Job -ID 10 -Timeout 120

Beenden eines Auftrags

Verwenden Sie das Cmdlet Stop-Job, um einen Hintergrundauftrag zu beenden. Mit dem folgenden Befehl wird ein Auftrag gestartet, um jeden Eintrag im Systemereignisprotokoll abzurufen. Es speichert das Auftragsobjekt in der $job Variablen.

$job = Start-Job -ScriptBlock {Get-EventLog -Log System}

Mit dem folgenden Befehl wird der Auftrag beendet. Es verwendet einen Pipelineoperator (|), um den Auftrag in der variablen $job an Stop-Jobzu senden.

$job | Stop-Job

Löschen eines Auftrags

Verwenden Sie das Cmdlet Remove-Job, um einen Hintergrundauftrag zu löschen. Mit dem folgenden Befehl wird der Auftrag in der variablen $job gelöscht.

Remove-Job -Job $job

Untersuchen eines fehlgeschlagenen Auftrags

Aufträge können aus vielen Gründen fehlschlagen. das Auftragsobjekt eine Reason-Eigenschaft enthält, die Informationen zur Ursache des Fehlers enthält.

Im folgenden Beispiel wird ein Auftrag ohne die erforderlichen Anmeldeinformationen gestartet.

$job = Start-Job -ScriptBlock {New-Item -Path HKLM:\Software\MyCompany}
Get-Job $job

Id Name  PSJobTypeName State  HasMoreData  Location  Command
-- ----  ------------- -----  -----------  --------  -------
1  Job1  BackgroundJob Failed False        localhost New-Item -Path HKLM:...

Überprüfen Sie die Reason-Eigenschaft, um den Fehler zu finden, der dazu führte, dass der Auftrag fehlschlug.

$job.ChildJobs[0].JobStateInfo.Reason

In diesem Fall ist der Auftrag fehlgeschlagen, da der Remotecomputer explizite Anmeldeinformationen zum Ausführen des Befehls benötigt hat. Die eigenschaft Reason enthält die folgende Meldung:

Fehler beim Herstellen einer Verbindung mit dem Remoteserver mit der folgenden Fehlermeldung: "Der Zugriff wurde verweigert".

Siehe auch

• about_Job_Details
• about_PSSessions
• über_Remote
• about_Remote_Jobs
• über_Thread_Jobs
• Invoke-Befehl
• Get-Job
• Empfangen-Auftrag
• Entfernen-Job
• Start-Job
• Stop-Job
• Warten-Job