能否复用已创建的PSJob而非新建？PowerShell 5.1性能优化需求

你提到的PSJob每次新建耗时的问题，本质是因为PSJob基于独立进程启动，重复创建会带来开销。下面针对PowerShell 5.1和高版本提供复用持久化作业的方案，同时满足你列出的所有需求：

PowerShell 5.1 实现：持久化后台作业 #

创建一个长期运行的后台作业，只启动一次，后续通过传递任务指令让它执行，避免重复创建进程。同时用全局互斥锁保证单实例，支持传参，输出保留到被请求时再返回。

# 检查是否已有名为"PersistentWorker"的作业在运行
$existingJob = Get-Job -Name "PersistentWorker" -ErrorAction SilentlyContinue
if (-not $existingJob -or $existingJob.State -notin 'Running', 'Completed') {
    # 全局互斥锁确保同一时间只有一个作业实例
    $mutex = New-Object System.Threading.Mutex($false, "Global\PersistentWorkerMutex")
    if (-not $mutex.WaitOne(0, $false)) {
        Write-Warning "已有一个PersistentWorker作业实例在运行"
        exit
    }

    # 启动持久化作业，内部循环监听任务
    Start-Job -Name "PersistentWorker" -ScriptBlock {
        $jobMutex = New-Object System.Threading.Mutex($false, "Global\PersistentWorkerMutex")
        try {
            $taskOutputs = @{} # 存储任务输出，直到被读取

            while ($true) {
                # 处理新任务：通过作业自定义属性接收脚本块和参数
                if ($this.CustomProperties.ContainsKey('NewTask')) {
                    $task = $this.CustomProperties['NewTask']
                    $taskId = [Guid]::NewGuid().ToString()
                    # 执行任务并保存输出
                    $taskOutputs[$taskId] = & $task.ScriptBlock @task.Parameters
                    # 清除任务标记，准备接收下一个
                    $this.CustomProperties.Remove('NewTask')
                    $this.CustomProperties['LastTaskId'] = $taskId
                }

                # 处理输出读取请求
                if ($this.CustomProperties['RequestOutput'] -eq $true) {
                    $this.CustomProperties['Output'] = $taskOutputs
                    $taskOutputs = @{} # 读取后清空输出池
                    $this.CustomProperties['RequestOutput'] = $false
                }

                Start-Sleep -Milliseconds 100 # 降低CPU占用
            }
        }
        finally {
            $jobMutex.ReleaseMutex()
        }
    } | Out-Null

    $mutex.ReleaseMutex()
}

# 准备要执行的任务（脚本块+参数）
$targetTask = @{
    ScriptBlock = { param($ServiceName) Get-Service -Name $ServiceName }
    Parameters = @{ ServiceName = 'WinRM' }
}

# 给持久化作业发送任务
$workerJob = Get-Job -Name "PersistentWorker"
$workerJob.CustomProperties['NewTask'] = $targetTask

# 等待任务执行（根据实际耗时调整等待时间）
Start-Sleep -Seconds 1

# 请求读取输出
$workerJob.CustomProperties['RequestOutput'] = $true
Start-Sleep -Milliseconds 200 # 等待作业处理请求

# 获取并显示结果
$workerJob.CustomProperties['Output'].Values | ForEach-Object { $_ }

# 如需停止作业，取消注释下面两行
# Stop-Job -Name "PersistentWorker"
# Remove-Job -Name "PersistentWorker"

方案符合的需求点： #

• 作业仅启动一次，驻留内存，避免重复创建进程的耗时
• 输出直接返回控制台，无磁盘写入
• 作业是独立的后台进程，与启动脚本完全分离
• 支持传入自定义参数，通过互斥锁保证单实例
• 输出会保留到你主动请求读取时才返回

PowerShell 7+ 优化方案：持久化线程作业 #

PowerShell 7及以上版本提供了Start-ThreadJob，它基于线程而非进程启动，速度更快、内存占用更低，同样可以实现持久化复用：

# 检查是否已有持久化线程作业在运行
$existingJob = Get-ThreadJob -Name "PersistentThreadWorker" -ErrorAction SilentlyContinue
if (-not $existingJob -or $existingJob.State -notin 'Running', 'Completed') {
    $mutex = New-Object System.Threading.Mutex($false, "Global\PersistentThreadWorkerMutex")
    if (-not $mutex.WaitOne(0, $false)) {
        Write-Warning "已有一个PersistentThreadWorker作业实例在运行"
        exit
    }

    # 启动线程作业，用并发队列处理任务
    Start-ThreadJob -Name "PersistentThreadWorker" -ScriptBlock {
        $jobMutex = New-Object System.Threading.Mutex($false, "Global\PersistentThreadWorkerMutex")
        try {
            $taskQueue = [System.Collections.Concurrent.ConcurrentQueue[hashtable]]::new()
            $outputDict = [System.Collections.Concurrent.ConcurrentDictionary[string, object]]::new()

            while ($true) {
                # 处理队列中的任务
                if ($taskQueue.TryDequeue([ref]$task)) {
                    $outputDict[$task.TaskId] = & $task.ScriptBlock @task.Parameters
                }

                # 处理输出读取请求
                if ($this.CustomProperties['RequestOutput'] -eq $true) {
                    $this.CustomProperties['Output'] = $outputDict.ToDictionary({$_.Key}, {$_.Value})
                    $outputDict.Clear()
                    $this.CustomProperties['RequestOutput'] = $false
                }

                Start-Sleep -Milliseconds 50
            }
        }
        finally {
            $jobMutex.ReleaseMutex()
        }
    } | Out-Null

    $mutex.ReleaseMutex()
}

# 提交带参数的任务
$taskId = [Guid]::NewGuid().ToString()
$targetTask = @{
    TaskId = $taskId
    ScriptBlock = { param($Path) Get-ChildItem -Path $Path -File }
    Parameters = @{ Path = 'C:\Windows\Temp' }
}

$workerJob = Get-ThreadJob -Name "PersistentThreadWorker"
$workerJob.CustomProperties['TaskQueue']?.Enqueue($targetTask)

# 等待任务执行完成
Start-Sleep -Milliseconds 500

# 请求读取输出
$workerJob.CustomProperties['RequestOutput'] = $true
Start-Sleep -Milliseconds 100

# 获取并显示结果
$workerJob.CustomProperties['Output'][$taskId] | Format-Table Name, Length

# 如需停止作业，取消注释下面两行
# Stop-ThreadJob -Name "PersistentThreadWorker"
# Remove-Job -Name "PersistentThreadWorker"

额外优势： #

• Start-ThreadJob启动速度比传统PSJob快数倍，内存占用更低
• 并发队列的使用让任务处理更高效，适合高频率任务场景

备选方案：独立PowerShell进程（完全解耦） #

如果需要完全脱离启动脚本的控制，也可以启动一个独立的PowerShell进程，通过标准IO传递任务指令：

# 检查是否已有独立工作进程在运行
$workerProcess = Get-Process powershell -ErrorAction SilentlyContinue | Where-Object { $_.CommandLine -match 'PersistentWorkerProcess' }
if (-not $workerProcess) {
    # 启动独立进程，循环监听输入指令
    $workerProcess = Start-Process powershell.exe -ArgumentList "-NoProfile -Command & {
        `$mutex = New-Object System.Threading.Mutex(`$false, 'Global\PersistentWorkerProcessMutex')
        try {
            while (`$true) {
                `$cmd = [Console]::In.ReadLine()
                if (`$cmd -eq 'exit') { break }
                # 解析并执行指令，输出转为JSON便于传递
                `$result = & [scriptblock]::Create(`$cmd)
                `$result | ConvertTo-Json -Compress
                Write-Host '---END---' # 输出结束标记
            }
        }
        finally {
            `$mutex.ReleaseMutex()
        }
    }" -PassThru -RedirectStandardOutput 'worker_out.tmp' -RedirectStandardInput 'worker_in.tmp'

    Start-Sleep -Seconds 1 # 等待进程初始化
}

# 发送带参数的任务指令
$taskCmd = "Get-Service -Name 'wuauserv'"
Add-Content 'worker_in.tmp' $taskCmd

# 读取输出直到结束标记
$outputLines = @()
$endFound = $false
while (-not $endFound) {
    Get-Content 'worker_out.tmp' -Tail 100 -Wait | ForEach-Object {
        if ($_ -eq '---END---') {
            $endFound = $true
        } else {
            $outputLines += $_
        }
    }
}

# 解析JSON并显示结果
$outputLines | ConvertFrom-Json | Format-Table Name, Status

# 如需停止进程，取消注释下面两行
# Add-Content 'worker_in.tmp' 'exit'
# Wait-Process $workerProcess.Id; Remove-Item 'worker_in.tmp','worker_out.tmp' -Force

这个方案的进程完全独立，即使启动脚本退出，工作进程也能继续运行，适合长期后台服务场景。

内容的提问来源于stack exchange，提问作者Aaron