Start-ThreadJob

  • Referência
Módulo:
ThreadJob

Cria trabalhos em segundo plano semelhantes ao Start-Job cmdlet.

Sintaxe

Start-ThreadJob
     [-ScriptBlock] <ScriptBlock>
     [-Name <String>]
     [-InitializationScript <ScriptBlock>]
     [-InputObject <PSObject>]
     [-ArgumentList <Object[]>]
     [-ThrottleLimit <Int32>]
     [-StreamingHost <PSHost>]
     [<CommonParameters>]
Start-ThreadJob
     [-FilePath] <String>
     [-Name <String>]
     [-InitializationScript <ScriptBlock>]
     [-InputObject <PSObject>]
     [-ArgumentList <Object[]>]
     [-ThrottleLimit <Int32>]
     [-StreamingHost <PSHost>]
     [<CommonParameters>]

Description

Start-ThreadJob Cria trabalhos em segundo plano semelhantes ao Start-Job cmdlet. A principal diferença é que os trabalhos criados são executados em threads separados dentro do processo local. Por padrão, os trabalhos usam o diretório de trabalho atual do chamador que iniciou o trabalho.

O cmdlet também dá suporte a um parâmetro ThrottleLimit para limitar o número de trabalhos em execução ao mesmo tempo. À medida que mais trabalhos são iniciados, eles são enfileirados e aguardam até que o número atual de trabalhos caia abaixo do limite de limitação.

Exemplos

Exemplo 1 – Criar trabalhos em segundo plano com um limite de thread de 2

Start-ThreadJob -ScriptBlock { 1..100 | % { sleep 1; "Output $_" } } -ThrottleLimit 2
Start-ThreadJob -ScriptBlock { 1..100 | % { sleep 1; "Output $_" } }
Start-ThreadJob -ScriptBlock { 1..100 | % { sleep 1; "Output $_" } }
Get-Job

Id   Name   PSJobTypeName   State        HasMoreData   Location     Command
--   ----   -------------   -----        -----------   --------     -------
1    Job1   ThreadJob       Running      True          PowerShell   1..100 | % { sleep 1;...
2    Job2   ThreadJob       Running      True          PowerShell   1..100 | % { sleep 1;...
3    Job3   ThreadJob       NotStarted   False         PowerShell   1..100 | % { sleep 1;...

Exemplo 2 – Comparar o desempenho de Start-Job e Start-ThreadJob

Este exemplo mostra a diferença entre Start-Job e Start-ThreadJob. Os trabalhos executam o Start-Sleep cmdlet por 1 segundo. Como os trabalhos são executados em paralelo, o tempo total de execução é de cerca de 1 segundo, mais o tempo necessário para criar os trabalhos.

# start five background jobs each running 1 second
Measure-Command {1..5 | % {Start-Job {Start-Sleep 1}} | Wait-Job} | Select-Object TotalSeconds
Measure-Command {1..5 | % {Start-ThreadJob {Start-Sleep 1}} | Wait-Job} | Select-Object TotalSeconds

TotalSeconds
------------
   5.7665849
   1.5735008

Depois de subtrair 1 segundo para o tempo de execução, você pode ver que Start-Job leva cerca de 4,8 segundos para criar cinco trabalhos. Start-ThreadJob é 8 vezes mais rápido, levando cerca de 0,6 segundos para criar cinco empregos. Os resultados podem variar em seu ambiente, mas a melhoria relativa deve ser a mesma.

Exemplo 3 – Criar trabalhos usando InputObject

Neste exemplo, o bloco de script usa a variável para receber entrada $input do parâmetro InputObject . Isso também pode ser feito canalizando objetos para Start-ThreadJob.

$j = Start-ThreadJob -InputObject (Get-Process pwsh) -ScriptBlock { $input | Out-String }
$j | Wait-Job | Receive-Job

NPM(K)    PM(M)      WS(M)     CPU(s)      Id  SI ProcessName
 ------    -----      -----     ------      --  -- -----------
     94   145.80     159.02      18.31   18276   1 pwsh
    101   163.30     222.05      29.00   35928   1 pwsh

$j = Get-Process pwsh | Start-ThreadJob -ScriptBlock { $input | Out-String }
$j | Wait-Job | Receive-Job

NPM(K)    PM(M)      WS(M)     CPU(s)      Id  SI ProcessName
 ------    -----      -----     ------      --  -- -----------
     94   145.80     159.02      18.31   18276   1 pwsh
    101   163.30     222.05      29.00   35928   1 pwsh

Exemplo 4 - Transmitir a saída do trabalho para o host pai

Usando o parâmetro StreamingHost , você pode dizer a um trabalho para direcionar toda a saída do host para um host específico. Sem esse parâmetro, a saída vai para a coleta de fluxo de dados do trabalho e não aparece em um console do host até que você receba a saída do trabalho.

Para este exemplo, o host atual é passado para usar Start-ThreadJob a $Host variável automática.

PS> Start-ThreadJob -ScriptBlock { Read-Host 'Say hello'; Write-Warning 'Warning output' } -StreamingHost $Host

Id   Name   PSJobTypeName   State         HasMoreData     Location      Command
--   ----   -------------   -----         -----------     --------      -------
7    Job7   ThreadJob       NotStarted    False           PowerShell    Read-Host 'Say hello'; ...

PS> Say hello: Hello
WARNING: Warning output
PS> Receive-Job -Id 7
Hello
WARNING: Warning output
PS>

Observe que o prompt de Read-Host é exibido e você pode digitar input. Em seguida, a mensagem de Write-Warning é exibida. O Receive-Job cmdlet retorna toda a saída do trabalho.

Exemplo 5 - Baixar vários arquivos ao mesmo tempo

O Invoke-WebRequest cmdlet só pode baixar um arquivo por vez. O exemplo a seguir usa Start-ThreadJob para criar vários trabalhos de thread para baixar vários arquivos ao mesmo tempo.

$baseUri = 'https://github.com/PowerShell/PowerShell/releases/download'
$files = @(
    @{
        Uri = "$baseUri/v7.3.0-preview.5/PowerShell-7.3.0-preview.5-win-x64.msi"
        OutFile = 'PowerShell-7.3.0-preview.5-win-x64.msi'
    },
    @{
        Uri = "$baseUri/v7.3.0-preview.5/PowerShell-7.3.0-preview.5-win-x64.zip"
        OutFile = 'PowerShell-7.3.0-preview.5-win-x64.zip'
    },
    @{
        Uri = "$baseUri/v7.2.5/PowerShell-7.2.5-win-x64.msi"
        OutFile = 'PowerShell-7.2.5-win-x64.msi'
    },
    @{
        Uri = "$baseUri/v7.2.5/PowerShell-7.2.5-win-x64.zip"
        OutFile = 'PowerShell-7.2.5-win-x64.zip'
    }
)

$jobs = @()

foreach ($file in $files) {
    $jobs += Start-ThreadJob -Name $file.OutFile -ScriptBlock {
        $params = $using:file
        Invoke-WebRequest @params
    }
}

Write-Host "Downloads started..."
Wait-Job -Job $jobs

foreach ($job in $jobs) {
    Receive-Job -Job $job
}

Parâmetros

-ArgumentList

Especifica uma matriz de argumentos, ou valores de parâmetro, para o script especificado pelos parâmetros FilePath ou ScriptBlock .

ArgumentList deve ser o último parâmetro na linha de comando. Todos os valores que seguem o nome do parâmetro são valores interpretados na lista de argumentos.

Tipo:Object[]
Cargo:Named
Valor padrão:None
Obrigatório:False
Aceitar a entrada de pipeline:False
Aceitar caracteres curinga:False

-FilePath

Especifica um arquivo de script a ser executado como um trabalho em segundo plano. Insira o caminho e o nome do arquivo do script. O script deve estar no computador local ou em uma pasta que o computador local possa acessar.

Quando você usa esse parâmetro, o PowerShell converte o conteúdo do arquivo de script especificado em um bloco de script e executa o bloco de script como um trabalho em segundo plano.

Tipo:String
Cargo:0
Valor padrão:None
Obrigatório:True
Aceitar a entrada de pipeline:False
Aceitar caracteres curinga:False

-InitializationScript

Especifica os comandos que são executados antes do trabalho ser iniciado. Coloque os comandos entre chaves ({}) para criar um bloco de script.

Use esse parâmetro para preparar a sessão na qual o trabalho é executado. Por exemplo, você pode usá-lo para adicionar funções e módulos à sessão.

Tipo:ScriptBlock
Cargo:Named
Valor padrão:None
Obrigatório:False
Aceitar a entrada de pipeline:False
Aceitar caracteres curinga:False

-InputObject

Especifica os objetos usados como entrada para o bloco de script. Ele também permite a entrada de pipeline. Use a $input variável automática no bloco de script para acessar os objetos de entrada.

Tipo:PSObject
Cargo:Named
Valor padrão:None
Obrigatório:False
Aceitar a entrada de pipeline:True
Aceitar caracteres curinga:False

-Name

Especifica um nome amigável para o novo trabalho. Você pode usar o nome para identificar o trabalho para outros cmdlets de trabalho, como o Stop-Job cmdlet.

O nome amigável padrão é "Job#", em que "#" é um número ordinal incrementado para cada trabalho.

Tipo:String
Cargo:Named
Valor padrão:None
Obrigatório:False
Aceitar a entrada de pipeline:False
Aceitar caracteres curinga:False

-ScriptBlock

Especifica os comandos a executar no trabalho em segundo plano. Coloque os comandos entre chaves ({}) para criar um bloco de script. Use a $Input variável automática para acessar o valor do parâmetro InputObject . Este parâmetro é obrigatório.

Tipo:ScriptBlock
Cargo:0
Valor padrão:None
Obrigatório:True
Aceitar a entrada de pipeline:False
Aceitar caracteres curinga:False

-StreamingHost

Esse parâmetro fornece uma maneira segura de thread para permitir que Write-Host a saída vá diretamente para o objeto PSHost passado. Sem ele, Write-Host a saída vai para a coleta de fluxo de dados de informações do trabalho e não aparece em um console de host até que os trabalhos terminem de ser executados.

Tipo:PSHost
Cargo:Named
Valor padrão:None
Obrigatório:False
Aceitar a entrada de pipeline:False
Aceitar caracteres curinga:False

-ThrottleLimit

Esse parâmetro limita o número de trabalhos em execução ao mesmo tempo. À medida que os trabalhos são iniciados, eles são enfileirados e aguardam até que um thread esteja disponível no pool de threads para executar o trabalho. O limite padrão é de 5 threads.

O tamanho do pool de threads é global para a sessão do PowerShell. Especificar um ThrottleLimit em uma chamada define o limite para chamadas subsequentes na mesma sessão.

Tipo:Int32
Cargo:Named
Valor padrão:5
Obrigatório:False
Aceitar a entrada de pipeline:False
Aceitar caracteres curinga:False

Entradas

PSObject

Saídas

ThreadJob.ThreadJob