¿Puede Powershell ejecutar comandos en paralelo?

Tengo un script de PowerShell para hacer un procesamiento por lotes en un montón de imágenes y me gustaría hacer un procesamiento paralelo. Powershell parece tener algunas opciones de procesamiento en segundo plano, como start-job, wait-job, etc., pero el único recurso bueno que encontré para hacer un trabajo paralelo fue escribir el texto de un script y ejecutarlo ( PowerShell Multithreading )

Idealmente, me gustaría algo similar a foreach paralelo en .net 4.

Algo bastante parecido a:

foreach-parallel -threads 4 ($file in (Get-ChildItem $dir))
{
   .. Do Work
}

Tal vez estaría mejor simplemente bajando a c # ...

Puede ejecutar trabajos paralelos en Powershell 2 utilizando trabajos en segundo plano . Consulte Start-Job y los otros cmdlets de trabajo.

# Loop through the server list
Get-Content "ServerList.txt" | %{

  # Define what each job does
  $ScriptBlock = {
    param($pipelinePassIn) 
    Test-Path "\\$pipelinePassIn\c`$\Something"
    Start-Sleep 60
  }

  # Execute the jobs in parallel
  Start-Job $ScriptBlock -ArgumentList $_
}

Get-Job

# Wait for it all to complete
While (Get-Job -State "Running")
{
  Start-Sleep 10
}

# Getting the information back from the jobs
Get-Job | Receive-Job

La respuesta de Steve Townsend es correcta en teoría, pero no en la práctica, como señaló @likwid. Mi código revisado tiene en cuenta la barrera del contexto laboral: ¡ nada cruza esa barrera por defecto! Por lo tanto, la $_variable automática se puede usar en el bucle pero no se puede usar directamente dentro del bloque de script porque está dentro de un contexto separado creado por el trabajo.

Para pasar variables del contexto primario al contexto secundario, use el -ArgumentListparámetro on Start-Jobpara enviarlo y use paramdentro del bloque de script para recibirlo.

cls
# Send in two root directory names, one that exists and one that does not.
# Should then get a "True" and a "False" result out the end.
"temp", "foo" | %{

  $ScriptBlock = {
    # accept the loop variable across the job-context barrier
    param($name) 
    # Show the loop variable has made it through!
    Write-Host "[processing '$name' inside the job]"
    # Execute a command
    Test-Path "\$name"
    # Just wait for a bit...
    Start-Sleep 5
  }

  # Show the loop variable here is correct
  Write-Host "processing $_..."

  # pass the loop variable across the job-context barrier
  Start-Job $ScriptBlock -ArgumentList $_
}

# Wait for all to complete
While (Get-Job -State "Running") { Start-Sleep 2 }

# Display output from all jobs
Get-Job | Receive-Job

# Cleanup
Remove-Job *

(En general, me gusta proporcionar una referencia a la documentación de PowerShell como evidencia de apoyo, pero, por desgracia, mi búsqueda ha sido infructuosa. Si sabe dónde está documentada la separación de contexto, ¡publique un comentario aquí para avisarme!)

http://gallery.technet.microsoft.com/scriptcenter/Invoke-Async-Allows-you-to-83b0c9f0

Creé un invoke-async que le permite ejecutar múltiples bloques de script / cmdlets / funciones al mismo tiempo. Esto es ideal para trabajos pequeños (escaneo de subred o consulta wmi en cientos de máquinas) porque la sobrecarga para crear un espacio de ejecución frente al tiempo de inicio del trabajo de inicio es bastante drástica. Se puede usar así.

con scriptblock,

$sb = [scriptblock] {param($system) gwmi win32_operatingsystem -ComputerName $system | select csname,caption} 

$servers = Get-Content servers.txt 

$rtn = Invoke-Async -Set $server -SetParam system  -ScriptBlock $sb

solo cmdlet / function

$servers = Get-Content servers.txt 

$rtn = Invoke-Async -Set $servers -SetParam computername -Params @{count=1} -Cmdlet Test-Connection -ThreadCount 50

Hay tantas respuestas a esto en estos días:

1. trabajos (o threadjobs en PS 6/7 o el módulo)
2. proceso de inicio
3. flujos de trabajo
4. API de PowerShell con otro espacio de ejecución
5. invocar-comando con múltiples computadoras, que pueden ser localeshost (tienen que ser admin)
6. pestañas de sesión múltiple (espacio de ejecución) en el ISE o pestañas ISE remotas de PowerShell
7. Powershell 7 tiene una foreach-object -parallelalternativa para # 4

Aquí hay flujos de trabajo con literalmente un foreach-paralelo:

workflow work {
  foreach -parallel ($i in 1..3) { 
    sleep 5 
    "$i done" 
  }
}

work

3 done
1 done
2 done

O un flujo de trabajo con un bloque paralelo:

function sleepfor($time) { sleep $time; "sleepfor $time done"}

workflow work {
  parallel {
    sleepfor 3
    sleepfor 2
    sleepfor 1
  }
  'hi'
}

work 

sleepfor 1 done
sleepfor 2 done
sleepfor 3 done
hi

Aquí hay un ejemplo de API con espacios de ejecución:

$a =  [PowerShell]::Create().AddScript{sleep 5;'a done'}
$b =  [PowerShell]::Create().AddScript{sleep 5;'b done'}
$c =  [PowerShell]::Create().AddScript{sleep 5;'c done'}
$r1,$r2,$r3 = ($a,$b,$c).begininvoke() # run in background
$a.EndInvoke($r1); $b.EndInvoke($r2); $c.EndInvoke($r3) # wait
($a,$b,$c).streams.error # check for errors
($a,$b,$c).dispose() # clean

a done
b done
c done

Los trabajos en segundo plano son caros de configurar y no son reutilizables. PowerShell MVP Oisin Grehan tiene un buen ejemplo de PowerShell multi-threading.

(25/10/2010 el sitio está inactivo, pero accesible a través del Archivo web).

He usado el script Oisin adaptado para usar en una rutina de carga de datos aquí:

http://rsdd.codeplex.com/SourceControl/changeset/view/a6cd657ea2be#Invoke-RSDDThreaded.ps1

Para completar las respuestas anteriores, también puede usar Wait-Jobpara esperar a que se completen todos los trabajos:

For ($i=1; $i -le 3; $i++) {
    $ScriptBlock = {
        Param (
            [string] [Parameter(Mandatory=$true)] $increment
        )

        Write-Host $increment
    }

    Start-Job $ScriptBlock -ArgumentList $i
}

Get-Job | Wait-Job | Receive-Job

En Powershell 7 puede usar ForEach-Object -Parallel

$Message = "Output:"
Get-ChildItem $dir | ForEach-Object -Parallel {
    "$using:Message $_"
} -ThrottleLimit 4

Si está utilizando el último PowerShell multiplataforma (que debería ser por cierto) https://github.com/powershell/powershell#get-powershell , puede agregar un solo &para ejecutar scripts paralelos. (Utilizar; para correr secuencialmente)

En mi caso, necesitaba ejecutar scripts de 2 npm en paralelo: npm run hotReload & npm run dev

También puede configurar npm para usarlo powershellen sus scripts (por defecto lo usa cmden Windows).

Ejecute desde la carpeta raíz del proyecto: npm config set script-shell pwsh --userconfig ./.npmrc y luego use el comando de script npm único:npm run start

"start":"npm run hotReload & npm run dev"