Wait-Job

Modul:

Microsoft.PowerShell.Core

Undertrycker kommandotolken tills ett eller alla Windows 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 Windows 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 är klara visar Wait-Job kommandotolken och returnerar ett jobbobjekt så att du kan skicka det till ett annat kommando.

Du kan använda cmdleten Wait-Job för att vänta på bakgrundsjobb, till exempel de som startades med hjälp av cmdleten Start-Job eller parametern AsJob i 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 också på anpassade jobbtyper, till exempel arbetsflödesjobb och instanser av schemalagda jobb. Om du vill aktivera 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

PS C:\> 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

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

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 kommandona Start-Job 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) av 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 av jobben som har slutförts.

Exempel 3: Avgör när det första bakgrundsjobbet är klart

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}

I det här exemplet används parametern Alla för Wait-Job 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ärrjobben har slutförts.

Det första kommandot skapar en PSSession- på var och en av datorerna som anges i Machines.txt-filen och lagrar PSSession-objekt i $s variabeln. 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 kommandot New-PSSession.

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

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

Kommandot använder Använda omfångsmodifierare för att ange att variabeln $c har definierats på den lokala datorn. Modifieraren Using scope introduceras i Windows PowerShell 3.0. Mer information om modifieraren Using scope finns i about_Remote_Variables (https://go.microsoft.com/fwlink/?LinkID=252653).

Det fjärde kommandot använder Invoke-Command för att köra kommandot Wait-Job i sessionerna. Den använder parametern Alla 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

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}

Det här exemplet visar hur du använder parametern Timeout för Wait-Job 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- objekt i variabeln $s.

Det andra kommandot använder Invoke-Command för att köra Start-Job i vart och ett av PSSession- objekt 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 parametern Timeout 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, efter 30 sekunder, har bara kommandot på Server02-datorn slutförts. 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

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

Det här kommandot identifierar tre jobb med sina ID:n och väntar tills något av dem har slutförts. Kommandotolken returneras när det första jobbet är klart.

Exempel 6: Vänta en period och låt sedan jobbet fortsätta i bakgrunden

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

Det här kommandot väntar 120 sekunder (två minuter) på att DailyLog-jobbet 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

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

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

Exempel 8: Vänta på jobb på den lokala datorn som startats med 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

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

Dessa kommandon startar ett jobb som hämtar Windows PowerShell-skriptfilerna 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 är klart 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

PS C:\> $s = New-PSSession Server01, Server02, Server03
PS C:\> $j = Invoke-Command -Session $s -ScriptBlock {Get-Process} -AsJob
PS C:\> $j | Wait-Job

Det här exemplet visar hur du använder Wait-Job- med jobb som startats på fjärrdatorer med hjälp av parametern AsJob för Invoke-Command. När du använder AsJobskapas 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 parametern AsJob för att köra kommandot asynkront som ett bakgrundsjobb. Kommandot returnerar ett jobbobjekt, precis som jobben som startades med hjälp av Start-Job, och jobbobjektet lagras i variabeln $j.

Det tredje kommandot använder en pipelineoperator (|) för att skicka jobbobjektet i $j till cmdleten Wait-Job. Ett Kommandot Invoke-Command 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

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

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

Parametrar

-Any

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

Typ:	SwitchParameter
Position:	Named
Standardvärde:	None
Obligatorisk:	False
Godkänn pipeline-indata:	False
Godkänn jokertecken:	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å 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.

Typ:	Hashtable
Position:	0
Standardvärde:	None
Obligatorisk:	True
Godkänn pipeline-indata:	True
Godkänn jokertecken:	False

-Force

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

• Fullbordad
• Misslyckades
• Stoppat
• Upphängd
• Bortkopplad

Den här parametern introducerades i Windows PowerShell 3.0.

Typ:	SwitchParameter
Position:	Named
Standardvärde:	None
Obligatorisk:	False
Godkänn pipeline-indata:	False
Godkänn jokertecken:	False

-Id

Anger en matris med ID:er 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.

Typ:	Int32[]
Position:	0
Standardvärde:	None
Obligatorisk:	True
Godkänn pipeline-indata:	True
Godkänn jokertecken:	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.

Typ:	Guid[]
Position:	0
Standardvärde:	None
Obligatorisk:	True
Godkänn pipeline-indata:	True
Godkänn jokertecken:	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 väntar Wait-Job på alla jobb som skapats i den aktuella sessionen.

Typ:	Job[]
Position:	0
Standardvärde:	None
Obligatorisk:	True
Godkänn pipeline-indata:	True
Godkänn jokertecken:	False

-Name

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

Typ:	String[]
Position:	0
Standardvärde:	None
Obligatorisk:	True
Godkänn pipeline-indata:	True
Godkänn jokertecken:	False

-State

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

• NotStarted
• Löpning
• Fullbordad
• Misslyckades
• Stoppat
• Blockerad
• Upphängd
• Bortkopplad
• Avbryta
• Stoppa

Mer information om jobbtillstånd finns i JobState Enumeration i MSDN-biblioteket.

Typ:	JobState
Godkända värden:	NotStarted, Running, Completed, Failed, Stopped, Blocked, Suspended, Disconnected, Suspending, Stopping, AtBreakpoint
Position:	0
Standardvärde:	None
Obligatorisk:	True
Godkänn pipeline-indata:	True
Godkänn jokertecken:	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 börjar när du skickar kommandot Wait-Job, 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.

Typ:	Int32
Alias:	TimeoutSec
Position:	Named
Standardvärde:	None
Obligatorisk:	False
Godkänn pipeline-indata:	False
Godkänn jokertecken:	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 de slutförda jobben. Om väntetiden slutar eftersom värdet för parametern timeout överskrids returnerar inte Wait-Job några objekt.

Kommentarer

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

• Fullbordad
• Misslyckades
• Stoppat
• Upphängd
• Frånkopplad Använd parametern Force om du vill dirigera Wait-Job- att fortsätta att vänta på pausade och frånkopplade jobb.

Relaterade länkar

• 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