Wait-Job

Referens

Modul:: Microsoft.PowerShell.Core

Undertrycker kommandotolken tills ett eller alla PowerShell-bakgrundsjobb som körs i sessionen har slutförts.

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 PowerShell-bakgrundsjobb ska slutföras innan kommandotolken visas. Du kan vänta tills ett bakgrundsjobb har slutförts eller tills alla bakgrundsjobb har slutförts och du kan ange en maximal väntetid för jobbet.

När kommandona i jobbet har slutförts Wait-Job visar kommandotolken och returnerar ett jobbobjekt så att du kan skicka det till ett annat kommando.

Du kan använda Wait-Job cmdleten för att vänta på bakgrundsjobb, till exempel de som startades med hjälp av cmdleten Start-Job eller asjob-parametern för cmdleten Invoke-Command . Mer information om Windows PowerShell bakgrundsjobb 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 bakgrundsjobb 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 bakgrundsjobb 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 Date1-jobben 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: Fastställ när det första bakgrundsjobbet har slutförts

$s = New-PSSession (Get-Content Machines.txt)
$c = 'Get-EventLog -LogName System | where {$_.EntryType -eq "error" --and $_.Source -eq "LSASRV"} | Out-File 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 bakgrundsjobb som körs i den aktuella sessionen har slutförts. 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 bakgrundsjobb 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 att använda omfångsmodifieraren 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 har slutförts.

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

$s = New-PSSession Server01, Server02, Server03
$jobs = Invoke-Command -Session $s -ScriptBlock {Start-Job -ScriptBlock {Get-Date}}
$done = Invoke-Command -Session $s -ScriptBlock {Wait-Job -Timeout 30}

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äntan, visar kommandotolken och returnerar objektet som representerar jobbet som slutfördes.

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:t och väntar tills något av dem har slutförts. Kommandotolken returneras 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 returneras kommandotolken ändå 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 *.ps1| where {$_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 bakgrundsjobb 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 har slutförts. 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 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 har slutförts.

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 bakgrundsjobb. 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 denna cmdlet visar kommandotolken och returnerar jobbobjektet 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 med standardbakgrundsjobb, 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 bakgrundsjobb 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 kommandotolken returneras, ä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 slutförda jobb. Om väntetiden slutar på grund av att värdet för timeout-parametern överskrids Wait-Job returnerar inte några objekt.

Kommentarer

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 att direkt Wait-Job ska fortsätta att vänta på pausade och frånkopplade jobb använder du parametern Force .