PowerShell多线程字符串替换异常：线程越多运行越慢

问题背景 #

为作业编写PowerShell脚本，要求用1、2、4、8线程实现字符串单词替换，当前用Start-Job和Wait-Job实现多线程。测试短字符串时发现异常：1线程耗时约700ms，线程数越多耗时越长，8线程耗时约1800ms。后续要处理5000、10000、20000词的字符串，不清楚问题原因。

原代码如下：

$inputString = "crush, deal, story, clap, early, pagan, fan, avian"
$substringToReplace = "crush"
$replacementSubstring = "red"

# number of jobs
$numJobs = 1

# spliting string to substrings for jobs
$words = $inputString -split " "
$numWordsPerSubstring = [Math]::round($words.Length / $numJobs)

$substrings = @()

for ($i = 0; $i -lt $numJobs; $i++) {
    $startIndex = $i * $numWordsPerSubstring
    $endIndex = [Math]::Min(($startIndex + $numWordsPerSubstring - 1), ($words.Length - 1))
    $substrings += ($words[$startIndex..$endIndex] -join " ") + " "
}

# scriptblock for jobs
$scriptBlock = {
    param($substring, $substringToReplace, $replacementSubstring)
    $substring -replace $substringToReplace, $replacementSubstring
}

$startTime = [Math]::Round((Get-Date).ToFileTime()/10000)
Write-Host "Start time is $startTime"

# starting each job
$jobs = foreach ($substring in $substrings) {
    #Write-Host "Job starte with substring $substring"
    Start-Job -ScriptBlock $scriptBlock -ArgumentList $substring, $substringToReplace, $replacementSubstring
}

# waiting for jobs to finnish
$outputString = ""
foreach ($job in $jobs) {
    #Write-Host "Job $job ended"
    $outputString += Wait-Job $job | Receive-Job
}

$endTime = [Math]::Round((Get-Date).ToFileTime()/10000)
Write-Host "End time is $endTime"

Write-Host "It took $($endTime - $startTime) milliseconds"

问题原因 #

1. Start-Job的进程级开销：每个Start-Job会启动独立的PowerShell子进程，进程的创建、初始化、通信和销毁都有显著开销。当任务本身工作量极小（比如短字符串替换），这些开销会完全盖过并行处理的收益，线程数越多，总开销累加越明显。
2. 任务粒度不合理：短字符串拆分后每个子任务的工作量太小，多线程调度、数据传递的成本远高于任务执行时间。
3. 等待方式低效：原代码中foreach ($job in $jobs)逐个调用Wait-Job，相当于串行等待任务完成，没有真正发挥多线程的并行优势。

解决方案 #

方案1：使用RunspacePool替代Start-Job #

Runspace是PowerShell进程内的线程池，开销远低于独立进程的Job，适合轻量并行任务。以下是改进后的代码：

$inputString = "crush, deal, story, clap, early, pagan, fan, avian"
$substringToReplace = "crush"
$replacementSubstring = "red"
$numThreads = 8

# 拆分字符串为任务块
$words = $inputString -split " "
$wordsPerBlock = [Math]::Ceiling($words.Length / $numThreads)
$taskBlocks = for ($i = 0; $i -lt $numThreads; $i++) {
    $start = $i * $wordsPerBlock
    $end = [Math]::Min(($start + $wordsPerBlock - 1), $words.Length - 1)
    if ($start -le $end) {
        $words[$start..$end] -join " "
    }
}
$taskBlocks = $taskBlocks | Where-Object { $_ } # 过滤空块

# 初始化RunspacePool
$runspacePool = [RunspaceFactory]::CreateRunspacePool(1, $numThreads)
$runspacePool.Open()

$jobs = @()
$scriptBlock = {
    param($block, $replaceFrom, $replaceTo)
    $block -replace $replaceFrom, $replaceTo
}

$startTime = [Math]::Round((Get-Date).ToFileTime()/10000)
Write-Host "Start time is $startTime"

# 提交任务到RunspacePool
foreach ($block in $taskBlocks) {
    $job = [PowerShell]::Create().AddScript($scriptBlock).AddArgument($block).AddArgument($substringToReplace).AddArgument($replacementSubstring)
    $job.RunspacePool = $runspacePool
    $jobs += @{ Job = $job; Handle = $job.BeginInvoke() }
}

# 等待所有任务完成并收集结果
$outputString = ""
foreach ($jobInfo in $jobs) {
    $outputString += $jobInfo.Job.EndInvoke($jobInfo.Handle)
    $jobInfo.Job.Dispose()
}

$runspacePool.Close()
$runspacePool.Dispose()

$endTime = [Math]::Round((Get-Date).ToFileTime()/10000)
Write-Host "End time is $endTime"
Write-Host "It took $($endTime - $startTime) milliseconds"

方案2：优化Start-Job的使用方式（适合入门过渡） #

如果暂时不想切换到Runspace，可优化等待逻辑并调整任务粒度：

• 使用Wait-Job -Job $jobs一次性等待所有任务完成，而非逐个等待
• 针对大字符串（5000+词）拆分任务，确保每个子任务有足够工作量，抵消进程开销

优化后的等待部分代码：

# 等待所有任务完成
Wait-Job -Job $jobs | Out-Null
# 收集所有结果
$outputString = ($jobs | Receive-Job) -join ""
# 清理Job
$jobs | Remove-Job

关键提示 #

• 对于CPU密集型小任务，RunspacePool的性能远优于Start-Job；对于IO密集型任务，Start-Job的开销影响相对较小，但Runspace仍更高效。
• 当处理5000+词的大字符串时，任务粒度足够大，多线程的收益会逐渐体现，此时无论是Runspace还是优化后的Start-Job，都能看到线程数增加带来的耗时减少。

内容的提问来源于stack exchange，提问作者Šimon Krížo