Nota:
El acceso a esta página requiere autorización. Puede intentar iniciar sesión o cambiar directorios.
El acceso a esta página requiere autorización. Puede intentar cambiar los directorios.
Descripción breve
Proporciona información sobre cómo los trabajos en segundo plano de PowerShell ejecutan un comando o expresión en segundo plano sin interactuar con la sesión actual.
Descripción larga
PowerShell ejecuta comandos y scripts simultáneamente a través de trabajos. PowerShell proporciona tres tipos de trabajos para admitir la simultaneidad.
-
RemoteJob: los comandos y los scripts se ejecutan en una sesión remota. Para obtener más información, consulte about_Remote_Jobs. -
BackgroundJob: los comandos y los scripts se ejecutan en un proceso independiente en el equipo local. -
PSTaskJoboThreadJob: los comandos y scripts se ejecutan en un subproceso independiente dentro del mismo proceso en el equipo local. Para obtener más información, vea about_Thread_Jobs.
La ejecución de scripts de forma remota, en una máquina independiente o en un proceso independiente, proporciona un gran aislamiento. Los errores que se producen en el trabajo remoto no afectan a otros trabajos en ejecución ni a la sesión primaria que inició el trabajo. Sin embargo, la capa de comunicación remota agrega sobrecarga, incluida la serialización de objetos. Todos los objetos se serializan y deserializan a medida que se pasan entre la sesión primaria y la sesión remota (trabajo). La serialización de objetos de datos complejos de gran tamaño puede consumir grandes cantidades de recursos de proceso y memoria y transferir grandes cantidades de datos a través de la red.
Los trabajos basados en subprocesos no son tan sólidos como trabajos remotos y en segundo plano, ya que se ejecutan en el mismo proceso en subprocesos diferentes. Si un trabajo tiene un error crítico que bloquea el proceso, se finalizan todos los demás trabajos del proceso.
Sin embargo, los trabajos basados en subprocesos requieren menos sobrecarga. No usan la capa de comunicación remota ni la serialización. Los objetos de resultado se devuelven como referencias a objetos activos en la sesión actual. Sin esta sobrecarga, los trabajos basados en subprocesos se ejecutan más rápido y usan menos recursos que los otros tipos de trabajo.
Importante
La sesión principal que creó el trabajo también supervisa el estado del trabajo y recopila datos de la canalización. El proceso principal termina el proceso secundario del trabajo una vez que el trabajo alcanza un estado finalizado. Si se termina la sesión principal, todos los trabajos secundarios en ejecución se terminan junto con sus procesos secundarios.
Hay dos maneras de solucionar esta situación:
- Use
Invoke-Commandpara crear trabajos que se ejecutan en sesiones desconectadas. Para obtener más información, vea about_Remote_Jobs. - Use
Start-Processpara crear un nuevo proceso en lugar de un trabajo. Para obtener más información, consulte Start-Process.
Cmdlets de trabajo
-
Start-Job: inicia un trabajo en segundo plano en un equipo local. -
Get-Job: obtiene los trabajos en segundo plano que se iniciaron en la sesión actual. -
Receive-Job: obtiene los resultados de los trabajos en segundo plano. -
Stop-Job: detiene un trabajo en segundo plano. -
Wait-Job: suprime el símbolo del sistema hasta que se completen uno o todos los trabajos. -
Remove-Job: elimina un trabajo en segundo plano. -
Invoke-Command: el parámetro AsJob crea un trabajo en segundo plano en un equipo remoto. Puede usarInvoke-Commandpara ejecutar cualquier comando de trabajo de forma remota, incluidoStart-Job.
Cómo iniciar un trabajo en el equipo local
Para iniciar un trabajo en segundo plano en el equipo local, use el cmdlet Start-Job.
Para escribir un comando Start-Job, escriba el comando que el trabajo ejecuta entre llaves ({}). Use el parámetro ScriptBlock para especificar el comando.
El comando siguiente inicia un trabajo en segundo plano que ejecuta un comando Get-Process en el equipo local.
Start-Job -ScriptBlock {Get-Process}
Cuando se inicia un trabajo en segundo plano, el símbolo del sistema se devuelve inmediatamente, incluso si el trabajo tarda un tiempo prolongado en completarse. Puede seguir trabajando en la sesión sin interrupciones mientras se ejecuta la tarea.
El comando Start-Job devuelve un objeto que representa el trabajo. El objeto de trabajo contiene información útil sobre el trabajo, pero no contiene los resultados del trabajo.
Puede guardar el objeto de trabajo en una variable y, a continuación, usarlo con los demás cmdlets de Job para administrar el trabajo en segundo plano. El comando siguiente inicia un objeto de trabajo y guarda el objeto de trabajo resultante en la variable $job.
$job = Start-Job -ScriptBlock {Get-Process}
A partir de PowerShell 6.0, puede usar el operador en segundo plano (&) al final de una canalización para iniciar un trabajo en segundo plano. Para obtener más información, vea operador en segundo plano.
El uso del operador en segundo plano es funcionalmente equivalente al uso del cmdlet Start-Job en el ejemplo anterior.
$job = Get-Process &
Obtención de objetos de trabajo
El cmdlet Get-Job devuelve objetos que representan los trabajos en segundo plano que se iniciaron en la sesión actual. Sin parámetros, Get-Job devuelve todos los trabajos que se iniciaron en la sesión actual.
Get-Job
El objeto de trabajo contiene el estado del trabajo, que indica si el trabajo ha finalizado. Un trabajo terminado tiene un estado de completado o Error. Un trabajo también puede ser bloqueado o En ejecución.
Id Name PSJobTypeName State HasMoreData Location Command
-- ---- ------------- ----- ----------- -------- -------
1 Job1 BackgroundJob Complete True localhost Get-Process
Puede guardar el objeto de trabajo en una variable y usarlo para representar el trabajo en un comando posterior. El comando siguiente obtiene el trabajo con el identificador 1 y lo guarda en la variable $job.
$job = Get-Job -Id 1
Obtención de los resultados de un trabajo
Al ejecutar un trabajo en segundo plano, los resultados no aparecen inmediatamente. Para obtener los resultados de un trabajo en segundo plano, use el cmdlet Receive-Job.
En el ejemplo siguiente, el cmdlet Receive-Job obtiene los resultados del trabajo mediante el objeto job en la variable $job.
Receive-Job -Job $job
Handles NPM(K) PM(K) WS(K) VM(M) CPU(s) Id ProcessName
------- ------ ----- ----- ----- ------ -- -----------
103 4 11328 9692 56 1176 audiodg
804 14 12228 14108 100 101.74 1740 CcmExec
668 7 2672 6168 104 32.26 488 csrss
...
Puede guardar los resultados de un trabajo en una variable. El comando siguiente guarda los resultados del trabajo en la variable $job en la variable $results.
$results = Receive-Job -Job $job
Obtención y mantenimiento de resultados de trabajos parciales
El cmdlet Receive-Job obtiene los resultados de un trabajo en segundo plano. Si se ha completado el trabajo, Receive-Job obtiene todos los resultados del trabajo. Si el trabajo sigue en ejecución, Receive-Job obtiene los resultados que se han generado hasta ahora. Puede ejecutar Receive-Job comandos de nuevo para obtener los resultados restantes.
De forma predeterminada, Receive-Job elimina los resultados de la memoria caché donde se almacenan los resultados del trabajo. Al volver a ejecutar Receive-Job, obtendrá solo los nuevos resultados que llegaron después de la primera ejecución.
Los comandos siguientes muestran los resultados de Receive-Job comandos se ejecutan antes de que se complete el trabajo.
C:\PS> Receive-Job -Job $job
Handles NPM(K) PM(K) WS(K) VM(M) CPU(s) Id ProcessName
------- ------ ----- ----- ----- ------ -- -----------
103 4 11328 9692 56 1176 audiodg
804 14 12228 14108 100 101.74 1740 CcmExec
C:\PS> Receive-Job -Job $job
Handles NPM(K) PM(K) WS(K) VM(M) CPU(s) Id ProcessName
------- ------ ----- ----- ----- ------ -- -----------
68 3 2632 664 29 0.36 1388 ccmsetup
749 22 21468 19940 203 122.13 3644 communicator
905 7 2980 2628 34 197.97 424 csrss
1121 25 28408 32940 174 430.14 3048 explorer
Use el parámetro Keep
C:\PS> Receive-Job -Job $job -Keep
Handles NPM(K) PM(K) WS(K) VM(M) CPU(s) Id ProcessName
------- ------ ----- ----- ----- ------ -- -----------
103 4 11328 9692 56 1176 audiodg
804 14 12228 14108 100 101.74 1740 CcmExec
C:\PS> Receive-Job -Job $job -Keep
Handles NPM(K) PM(K) WS(K) VM(M) CPU(s) Id ProcessName
------- ------ ----- ----- ----- ------ -- -----------
103 4 11328 9692 56 1176 audiodg
804 14 12228 14108 100 101.74 1740 CcmExec
68 3 2632 664 29 0.36 1388 ccmsetup
749 22 21468 19940 203 122.13 3644 communicator
905 7 2980 2628 34 197.97 424 csrss
1121 25 28408 32940 174 430.14 3048 explorer
Esperando los resultados
Si ejecuta un comando que tarda mucho tiempo en completarse, puede usar las propiedades del objeto de trabajo para determinar cuándo se ha completado el trabajo. El comando siguiente usa el objeto Get-Job para obtener todos los trabajos en segundo plano de la sesión actual.
Get-Job
Los resultados aparecen en una tabla. El estado del trabajo aparece en la columna Estado.
Id Name PSJobTypeName State HasMoreData Location Command
-- ---- ------------- ----- ----------- -------- -------
1 Job1 BackgroundJob Complete True localhost Get-Process
2 Job2 BackgroundJob Running True localhost Get-EventLog -Log ...
3 Job3 BackgroundJob Complete True localhost dir -Path C:\* -Re...
En este caso, la propiedad State revela que el trabajo 2 todavía se está ejecutando. Si usara el cmdlet Receive-Job para obtener los resultados del trabajo ahora, los resultados estarían incompletos. Puede usar el cmdlet Receive-Job repetidamente para obtener todos los resultados. Use la propiedad state
También puede usar el parámetro wait
También puede usar el cmdlet Wait-Job para esperar a cualquiera o todos los resultados del trabajo.
Wait-Job le permite esperar uno o varios trabajos específicos o para todos los trabajos.
El siguiente comando usa el cmdlet Wait-Job para esperar un trabajo con id. 10.
Wait-Job -ID 10
Como resultado, el símbolo del sistema de PowerShell se suprime hasta que se completa el trabajo.
También puede esperar un período predeterminado de tiempo. Este comando usa el parámetro timeout para limitar la espera a 120 segundos. Cuando expire el tiempo, el símbolo del sistema devuelve, pero el trabajo continúa ejecutándose en segundo plano.
Wait-Job -ID 10 -Timeout 120
Detener un trabajo
Para detener un trabajo en segundo plano, use el cmdlet Stop-Job. El comando siguiente inicia un trabajo para obtener cada entrada en el registro de eventos del sistema. Guarda el objeto de trabajo en la variable $job.
$job = Start-Job -ScriptBlock {Get-EventLog -Log System}
El comando siguiente detiene el trabajo. Usa un operador de canalización (|) para enviar el trabajo en la variable $job a Stop-Job.
$job | Stop-Job
Eliminación de un trabajo
Para eliminar un trabajo en segundo plano, use el cmdlet Remove-Job. El comando siguiente elimina el trabajo en la variable $job.
Remove-Job -Job $job
Investigación de un trabajo con errores
Los trabajos pueden producir errores por muchas razones. el objeto de trabajo contiene una propiedad Reason que contiene información sobre la causa del error.
En el ejemplo siguiente se inicia un trabajo sin las credenciales necesarias.
$job = Start-Job -ScriptBlock {New-Item -Path HKLM:\Software\MyCompany}
Get-Job $job
Id Name PSJobTypeName State HasMoreData Location Command
-- ---- ------------- ----- ----------- -------- -------
1 Job1 BackgroundJob Failed False localhost New-Item -Path HKLM:...
Inspeccione la propiedad Reason para encontrar el error que provocó un error en el trabajo.
$job.ChildJobs[0].JobStateInfo.Reason
En este caso, se produjo un error en el trabajo porque el equipo remoto requería credenciales explícitas para ejecutar el comando . La propiedad Reason de
Error al conectarse al servidor remoto con el siguiente mensaje de error: "Se deniega el acceso".