Dela via

Wait-Job

  • Referens
Modul:
Microsoft.PowerShell.Core

Väntar tills ett eller alla PowerShell-jobb som körs i sessionen är i ett avslutande tillstånd.

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

Description

Cmdleten Wait-Job väntar på att ett jobb ska vara i ett avslutande tillstånd innan körningen fortsätter. Avslutande tillstånd är:

  • Slutförd
  • Misslyckad
  • Stoppad
  • Inaktiverad
  • Frånkopplad

Du kan vänta tills ett angivet jobb eller alla jobb är i ett avslutande tillstånd. Du kan också ange en maximal väntetid för jobbet med hjälp av timeout-parametern eller använda parametern Force för att vänta på ett jobb i tillstånden Suspended eller Disconnected .

När kommandona i jobbet har slutförts Wait-Job returnerar ett jobbobjekt och fortsätter körningen.

Du kan använda cmdleten Wait-Job för att vänta på jobb som startats med hjälp av cmdleten Start-Job eller asjob-parametern för cmdleten Invoke-Command . Mer information om jobb finns i about_Jobs.

Från och med Windows PowerShell 3.0 väntar cmdleten Wait-Job även på anpassade jobbtyper, till exempel arbetsflödesjobb och instanser av schemalagda jobb. Om du vill aktivera Wait-Job att vänta på jobb av en viss typ importerar du modulen som stöder den anpassade jobbtypen till sessionen innan du kör cmdleten Get-Job , antingen med hjälp av cmdleten Import-Module eller genom att använda eller hämta en cmdlet i modulen. Information om en viss typ av anpassat jobb finns i dokumentationen för funktionen för anpassad jobbtyp.

Exempel

Exempel 1: Vänta på alla jobb

Get-Job | Wait-Job

Det här kommandot väntar på att alla jobb som körs i sessionen ska slutföras.

Exempel 2: Vänta på jobb som startats på fjärrdatorer med hjälp av 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

Det här exemplet visar hur du använder cmdleten Wait-Job med jobb som startats på fjärrdatorer med hjälp av cmdleten Start-Job . Både Start-Job kommandona och Wait-Job skickas till fjärrdatorn med hjälp av cmdleten Invoke-Command .

I det här exemplet används Wait-Job för att avgöra om ett Get-Date kommando som körs som ett jobb på tre olika datorer har slutförts.

Det första kommandot skapar en Windows PowerShell session (PSSession) på var och en av de tre fjärrdatorerna och lagrar dem i variabeln $s .

Det andra kommandot använder Invoke-Command för att köra Start-Job i var och en av de tre sessionerna i $s. Alla jobb har namnet Date1.

Det tredje kommandot använder Invoke-Command för att köra Wait-Job. Det här kommandot väntar på att jobben Date1 på varje dator ska slutföras. Den lagrar den resulterande samlingen (matrisen) med jobbobjekt i variabeln $done .

Det fjärde kommandot använder egenskapen Count för matrisen med jobbobjekt i variabeln $done för att avgöra hur många jobb som har slutförts.

Exempel 3: Avgöra när det första jobbet har slutförts

$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}

I det här exemplet används parametern Wait-JobAny för för att avgöra när det första av många jobb som körs i den aktuella sessionen är i ett avslutande tillstånd. Den visar också hur du använder cmdleten Wait-Job för att vänta tills fjärrjobb har slutförts.

Det första kommandot skapar en PSSession på var och en av datorerna som anges i filen Machines.txt och lagrar PSSession-objekten i variabeln $s . Kommandot använder cmdleten Get-Content för att hämta innehållet i filen. Kommandot Get-Content omges av parenteser för att se till att det körs före New-PSSession kommandot.

Det andra kommandot lagrar en Get-EventLog kommandosträng, inom citattecken, i variabeln $c .

Det tredje kommandot använder Invoke-Command cmdleten för att köra Start-Job i var och en av sessionerna i $s. Kommandot Start-Job startar ett jobb som kör Get-EventLog kommandot i variabeln $c .

Kommandot använder modifieraren Using scope (Använda omfång) för att ange att variabeln $c har definierats på den lokala datorn. Modifieraren Using scope (Använda omfång) introduceras i Windows PowerShell 3.0. Mer information om hur du använder omfångsmodifierare finns i about_Remote_Variables.

Det fjärde kommandot använder Invoke-Command för att köra ett Wait-Job kommando i sessionerna. Den använder parametern Any för att vänta tills det första jobbet på fjärrdatorerna avslutas.

Exempel 4: Ange en väntetid för jobb på fjärrdatorer

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>

Det här exemplet visar hur du använder timeout-parameternWait-Job för för att ange en maximal väntetid för jobb som körs på fjärrdatorer.

Det första kommandot skapar en PSSession på var och en av tre fjärrdatorer (Server01, Server02 och Server03) och lagrar sedan PSSession-objekten i variabeln $s .

Det andra kommandot använder Invoke-Command för att köra Start-Job i vart och ett av PSSession-objekten i $s. Den lagrar de resulterande jobbobjekten i variabeln $jobs .

Det tredje kommandot använder Invoke-Command för att köra Wait-Job i var och en av sessionerna i $s. Kommandot Wait-Job avgör om alla kommandon har slutförts inom 30 sekunder. Den använder timeout-parametern med värdet 30 för att fastställa den maximala väntetiden och lagrar sedan resultatet av kommandot i variabeln $done .

I det här fallet är det bara kommandot på Server02-datorn som har slutförts efter 30 sekunder. Wait-Job avslutar väntetiden, returnerar objektet som representerar jobbet som slutfördes och visar kommandotolken.

Variabeln $done innehåller ett jobbobjekt som representerar jobbet som kördes på Server02.

Exempel 5: Vänta tills ett av flera jobb har slutförts

Wait-Job -id 1,2,5 -Any

Det här kommandot identifierar tre jobb efter deras ID:n och väntar tills någon av dem är i ett avslutande tillstånd. Körningen fortsätter när det första jobbet har slutförts.

Exempel 6: Vänta en period och tillåt sedan att jobbet fortsätter i bakgrunden

Wait-Job -Name "DailyLog" -Timeout 120

Det här kommandot väntar 120 sekunder (två minuter) på att Jobbet DailyLog ska slutföras. Om jobbet inte slutförs inom de närmaste två minuterna fortsätter körningen och jobbet fortsätter att köras i bakgrunden.

Exempel 7: Vänta på ett jobb efter namn

Wait-Job -Name "Job3"

Det här kommandot använder jobbnamnet för att identifiera jobbet som ska vänta.

Exempel 8: Vänta tills jobb på den lokala datorn har startats med Start-Job

$j = Start-Job -ScriptBlock {Get-ChildItem -Filter *.ps1| Where-Object {$PSItem.LastWriteTime -gt ((Get-Date) - (New-TimeSpan -Days 7))}}
$j | Wait-Job

Det här exemplet visar hur du använder cmdleten Wait-Job med jobb som startats på den lokala datorn med hjälp Start-Jobav .

De här kommandona startar ett jobb som hämtar Windows PowerShell skriptfiler som har lagts till eller uppdaterats under den senaste veckan.

Det första kommandot använder Start-Job för att starta ett jobb på den lokala datorn. Jobbet kör ett Get-ChildItem kommando som hämtar alla filer som har ett .ps1 filnamnstillägg som har lagts till eller uppdaterats under den senaste veckan.

Det tredje kommandot använder Wait-Job för att vänta tills jobbet är i ett avslutande tillstånd. När jobbet har slutförts visar kommandot jobbobjektet, som innehåller information om jobbet.

Exempel 9: Vänta på jobb som startats på fjärrdatorer med hjälp av Invoke-Command

$s = New-PSSession -ComputerName Server01, Server02, Server03
$j = Invoke-Command -Session $s -ScriptBlock {Get-Process} -AsJob
$j | Wait-Job

Det här exemplet visar hur du använder Wait-Job med jobb som startas på fjärrdatorer med hjälp av asjob-parametern för Invoke-Command. När du använder AsJob skapas jobbet på den lokala datorn och resultatet returneras automatiskt till den lokala datorn, även om jobbet körs på fjärrdatorerna.

I det här exemplet används Wait-Job för att avgöra om ett Get-Process kommando som körs i sessionerna på tre fjärrdatorer är i ett avslutande tillstånd.

Det första kommandot skapar PSSession-objekt på tre datorer och lagrar dem i variabeln $s .

Det andra kommandot använder Invoke-Command för att köra Get-Process i var och en av de tre sessionerna i $s. Kommandot använder asjob-parametern för att köra kommandot asynkront som ett jobb. Kommandot returnerar ett jobbobjekt, precis som jobben som startades med , Start-Joboch jobbobjektet lagras i variabeln $j .

Det tredje kommandot använder en pipelineoperator (|) för att skicka jobbobjektet $j till cmdleten Wait-Job . Ett Invoke-Command kommando krävs inte i det här fallet eftersom jobbet finns på den lokala datorn.

Exempel 10: Vänta på ett jobb som har ett 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

Det här kommandot väntar på jobbet med ID-värdet 1.

Parametrar

-Any

Anger att den här cmdleten returnerar jobbobjektet och fortsätter körningen när ett jobb har slutförts. Som standard Wait-Job väntar tills alla angivna jobb har slutförts innan prompten visas.

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

-Filter

Anger en hash-tabell med villkor. Den här cmdleten väntar på jobb som uppfyller alla villkor i hash-tabellen. Ange en hash-tabell där nycklarna är jobbegenskaper och värdena är jobbegenskapsvärden.

Den här parametern fungerar bara på anpassade jobbtyper, till exempel arbetsflödesjobb och schemalagda jobb. Det fungerar inte på standardjobb, till exempel de som skapas med hjälp av cmdleten Start-Job . Information om stöd för den här parametern finns i hjälpavsnittet för jobbtypen.

Den här parametern introducerades i Windows PowerShell 3.0.

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

-Force

Anger att den här cmdleten fortsätter att vänta på jobb i tillståndet Pausad eller Frånkopplad. Som standard Wait-Job returnerar eller avslutar du vänteläget när jobben är i något av följande tillstånd:

  • Slutförd
  • Misslyckad
  • Stoppad
  • Inaktiverad
  • Frånkopplad

Den här parametern introducerades i Windows PowerShell 3.0.

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

-Id

Anger en matris med ID:t för jobb som den här cmdleten väntar på.

ID:t är ett heltal som unikt identifierar jobbet i den aktuella sessionen. Det är lättare att komma ihåg och skriva än instans-ID, men det är bara unikt i den aktuella sessionen. Du kan skriva ett eller flera ID:er avgränsade med kommatecken. Om du vill hitta ID:t för ett jobb skriver du Get-Job.

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

-InstanceId

Anger en matris med instans-ID:t för jobb som cmdleten väntar på. Standardvärdet är alla jobb.

Ett instans-ID är ett GUID som unikt identifierar jobbet på datorn. Om du vill hitta instans-ID:t för ett jobb använder du Get-Job.

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

-Job

Anger de jobb som cmdleten väntar på. Ange en variabel som innehåller jobbobjekten eller ett kommando som hämtar jobbobjekten. Du kan också använda en pipelineoperator för att skicka jobbobjekt till cmdleten Wait-Job . Som standard Wait-Job väntar alla jobb som skapats i den aktuella sessionen.

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

-Name

Anger egna namn på jobb som cmdleten väntar på.

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

-State

Anger ett jobbtillstånd. Den här cmdleten väntar bara på jobb i det angivna tillståndet. De acceptabla värdena för den här parametern är:

  • NotStarted
  • Körs
  • Slutförd
  • Misslyckad
  • Stoppad
  • Blockerad
  • Inaktiverad
  • Frånkopplad
  • Pausar
  • Stoppas

Mer information om jobbtillstånd finns i JobState-uppräkning.

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

Anger den maximala väntetiden för varje jobb, i sekunder. Standardvärdet -1 anger att cmdleten väntar tills jobbet har slutförts. Tidpunkten startar när du skickar Wait-Job kommandot, inte kommandot Start-Job .

Om den här tiden överskrids avslutas väntetiden och körningen fortsätter, även om jobbet fortfarande körs. Kommandot visar inget felmeddelande.

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

Indata

System.Management.Automation.RemotingJob

Du kan skicka ett jobbobjekt till den här cmdleten.

Utdata

System.Management.Automation.PSRemotingJob

Den här cmdleten returnerar jobbobjekt som representerar jobben i ett avslutande tillstånd. Om väntetiden slutar på grund av att värdet för timeout-parametern har överskridits Wait-Job returnerar inte några objekt.

Kommentarer

PowerShell innehåller följande alias för Wait-Job:

  • Alla plattformar:
    • wjb

Som standard Wait-Job returnerar eller avslutar väntetiden när jobben är i något av följande tillstånd:

  • Slutförd
  • Misslyckad
  • Stoppad
  • Inaktiverad
  • Frånkopplad

Om du vill fortsätta Wait-Job att vänta på pausade och frånkopplade jobb använder du parametern Force .