O processamento paralelo é uma técnica que permite a execução simultânea de múltiplas tarefas para melhorar a eficiência e reduzir o tempo de execução de processos complexos. No ambiente Windows, o PowerShell oferece funcionalidades robustas para implementar processamento paralelo, aproveitando os recursos de hardware disponíveis, como múltiplos núcleos de CPU.

O PowerShell, uma ferramenta de automação e configuração de tarefas, é uma escolha excelente para realizar processamento paralelo devido à sua capacidade de gerenciar tarefas assíncronas e pipelines de dados. Este artigo irá explorar como você pode utilizar o PowerShell para executar tarefas em paralelo, fornecendo exemplos práticos para ilustrar o processo.

Exemplos:

1. Usando ForEach-Object -Parallel no PowerShell 7+

O PowerShell 7 introduziu o parâmetro -Parallel para o cmdlet ForEach-Object, que facilita a execução de scripts em paralelo.

   $numbers = 1\..10



   $numbers | ForEach-Object -Parallel {

       Start-Sleep -Seconds $_

       "Processed $_"

   }

Neste exemplo, cada número de 1 a 10 é processado em paralelo, com um atraso correspondente ao valor do número. O comando Start-Sleep simula uma tarefa que consome tempo.

2. Usando Jobs no PowerShell

Outra abordagem é utilizar jobs, que são tarefas assíncronas que podem ser gerenciadas e monitoradas.

   $jobs = @()



   foreach ($i in 1\..10) {

       $jobs += Start-Job -ScriptBlock {

           Start-Sleep -Seconds 5

           "Job $($using:i) completed"

       }

   }



   # Aguardar todos os jobs completarem

   $jobs | ForEach-Object { $_ | Wait-Job }



   # Obter resultados dos jobs

   $jobs | ForEach-Object { Receive-Job -Job $_ }

Neste exemplo, criamos 10 jobs que executam em paralelo, cada um com um atraso de 5 segundos. Usamos Start-Job para iniciar os jobs, Wait-Job para aguardar a conclusão e Receive-Job para obter os resultados.

3. Usando Runspaces

Para um controle mais granular e melhor desempenho, podemos usar runspaces, que são threads leves.

   $runspaces = [System.Collections.ArrayList]::new()

   $runspacePool = [runspacefactory]::CreateRunspacePool(1, [Environment]::ProcessorCount)

   $runspacePool.Open()



   1\..10 | ForEach-Object {

       $runspace = [powershell]::Create().AddScript({

           param ($i)

           Start-Sleep -Seconds $i

           "Runspace $i completed"

       }).AddArgument($_)



       $runspace.RunspacePool = $runspacePool

       $runspaces.Add([pscustomobject]@{ Pipe = $runspace; Status = $runspace.BeginInvoke() })

   }



   $runspaces | ForEach-Object {

       $_.Pipe.EndInvoke($_.Status)

       $_.Pipe.Dispose()

   }



   $runspacePool.Close()

   $runspacePool.Dispose()

Neste exemplo, utilizamos runspaces para criar threads leves que executam em paralelo. Cada runspace executa um script com um atraso correspondente ao seu índice.

Este artigo demonstrou como utilizar o PowerShell para realizar processamento paralelo no Windows, oferecendo diferentes abordagens que podem ser adaptadas conforme a complexidade e os requisitos específicos das suas tarefas.