# 定义需要检查的服务器列表
$servers = @(
    'server-01.example.com'
    'server-02.example.com'
    'server-03.example.com'
    'server-04.example.com'
    'server-05.example.com'
)

# 方式一：使用 Start-Job（独立进程，开销较大）
$processJobs = foreach ($server in $servers) {
    Start-Job -ScriptBlock {
        param($target)
        $result = Test-Connection -TargetName $target -Count 2 -Quiet
        [PSCustomObject]@{
            Server   = $target
            Online   = $result
            Response = if ($result) { 'OK' } else { 'Timeout' }
        }
    } -ArgumentList $server -Name "Ping_$($server)"
}

# 方式二：使用 ThreadJob（线程级，开销更小）
$threadJobs = foreach ($server in $servers) {
    Start-ThreadJob -ScriptBlock {
        param($target)
        $sw = [System.Diagnostics.Stopwatch]::StartNew()
        $result = Test-Connection -TargetName $target -Count 2 -Quiet
        $sw.Stop()
        [PSCustomObject]@{
            Server    = $target
            Online    = $result
            Duration  = $sw.ElapsedMilliseconds
        }
    } -ArgumentList $server -Name "TPing_$($server)"
}

# 跟踪任务状态
Write-Host "=== 任务状态 ==="
Get-Job | Format-Table Name, State, HasMoreData -AutoSize

# 等待所有 ThreadJob 完成（超时 30 秒）
Wait-Job -Job $threadJobs -Timeout 30 | Out-Null

# 收集结果
Write-Host "`n=== ThreadJob 结果 ==="
$results = $threadJobs | Receive-Job
$results | Format-Table Server, Online, Duration -AutoSize

# 清理已完成任务
Get-Job | Remove-Job

# 模拟一批需要处理的 URL
$urls = @(
    'https://httpbin.org/delay/1'
    'https://httpbin.org/delay/2'
    'https://httpbin.org/delay/1'
    'https://httpbin.org/delay/3'
    'https://httpbin.org/delay/1'
    'https://httpbin.org/delay/2'
    'https://httpbin.org/delay/1'
    'https://httpbin.org/delay/2'
)

# 外部变量：请求超时和重试次数
$timeoutSec = 10
$maxRetries = 2

# 并行请求，限制并发数为 4
$measure = Measure-Command {
    $results = $urls | ForEach-Object -ThrottleLimit 4 -Parallel {
        $url = $_
        $timeout = $using:timeoutSec
        $retries = $using:maxRetries

        $attempt = 0
        $success = $false
        $sw = [System.Diagnostics.Stopwatch]::StartNew()

        while ($attempt -lt $retries -and -not $success) {
            $attempt++
            try {
                $response = Invoke-WebRequest -Uri $url -TimeoutSec $timeout `
                    -UseBasicParsing -ErrorAction Stop
                $success = $true
                $sw.Stop()
            }
            catch {
                $sw.Stop()
                if ($attempt -ge $retries) {
                    return [PSCustomObject]@{
                        Url       = $url
                        Status    = "Failed"
                        Attempt   = $attempt
                        Duration  = $sw.ElapsedMilliseconds
                        Error     = $_.Exception.Message
                    }
                }
                $sw.Start()
            }
        }

        [PSCustomObject]@{
            Url      = $url
            Status   = "$($response.StatusCode)"
            Attempt  = $attempt
            Duration = $sw.ElapsedMilliseconds
        }
    }

    $results | Format-Table Url, Status, Attempt, Duration -AutoSize
}

Write-Host "`n总耗时: $($measure.TotalSeconds.ToString('F1')) 秒"

# 任务列表：批量获取多个远程主机的系统信息
$targets = 1..20 | ForEach-Object { "host-$($_.ToString('00'))" }

# 创建初始 Session State（可预加载模块和变量）
$initialSessionState = [System.Management.Automation.Runspaces.InitialSessionState]::CreateDefault()

# 创建 Runspace 池，最大 8 个并发
$runspacePool = [System.Management.Automation.Runspaces.RunspaceFactory]::CreateRunspacePool(
    1, 8, $initialSessionState, $Host
)
$runspacePool.Open()

# 定义任务脚本
$scriptBlock = {
    param($computerName)
    $sw = [System.Diagnostics.Stopwatch]::StartNew()

    # 模拟远程查询（实际可用 Invoke-Command 或 CIM 查询）
    Start-Sleep -Milliseconds (Get-Random -Minimum 100 -Maximum 2000)

    $sw.Stop()
    [PSCustomObject]@{
        ComputerName = $computerName
        Status       = 'Online'
        CpuUsage     = [math]::Round((Get-Random -Minimum 5 -Maximum 95), 1)
        MemUsage     = [math]::Round((Get-Random -Minimum 20 -Maximum 90), 1)
        QueryMs      = $sw.ElapsedMilliseconds
    }
}

# 创建并启动所有任务
$runspaces = foreach ($target in $targets) {
    $powershell = [System.Management.Automation.PowerShell]::Create().AddScript($scriptBlock).AddArgument($target)
    $powershell.RunspacePool = $runspacePool

    [PSCustomObject]@{
        PowerShell = $powershell
        Handle     = $powershell.BeginInvoke()
        Target     = $target
    }
}

# 异步等待并收集结果
$completed = [System.Collections.Generic.List[PSObject]]::new()
$totalMs = [System.Diagnostics.Stopwatch]::StartNew()

foreach ($rs in $runspaces) {
    try {
        $result = $rs.PowerShell.EndInvoke($rs.Handle)
        if ($result) {
            $completed.Add($result[0])
        }
    }
    catch {
        $completed.Add([PSCustomObject]@{
            ComputerName = $rs.Target
            Status       = "Error: $($_.Exception.Message)"
            CpuUsage     = 0
            MemUsage     = 0
            QueryMs      = 0
        })
    }
    finally {
        $rs.PowerShell.Dispose()
    }
}

$totalMs.Stop()

# 输出结果（按查询耗时排序）
$completed | Sort-Object QueryMs | Format-Table ComputerName, Status, CpuUsage, MemUsage, QueryMs -AutoSize
Write-Host "`n完成 $($completed.Count)/$($targets.Count) 台，总耗时: $($totalMs.ElapsedMilliseconds) ms"

# 释放 Runspace 池资源
$runspacePool.Close()
$runspacePool.Dispose()

# 三种方式处理 10 万条数据的性能对比
$count = 100000

# 方式一：数组累加（+=）——每次都创建新数组，性能最差
$result1 = @()
$sw1 = [System.Diagnostics.Stopwatch]::StartNew()
for ($i = 1; $i -le $count; $i++) {
    if ($i % 2 -eq 0) {
        $result1 += "Item-$i"
    }
}
$sw1.Stop()
$time1 = $sw1.Elapsed.TotalMilliseconds
$mem1 = [System.GC]::GetTotalMemory($true)

# 方式二：管道 + Where-Object —— 延迟枚举，内存友好
$sw2 = [System.Diagnostics.Stopwatch]::StartNew()
$result2 = 1..$count | Where-Object { $_ % 2 -eq 0 } | ForEach-Object { "Item-$_" }
$sw2.Stop()
$time2 = $sw2.Elapsed.TotalMilliseconds
$mem2 = [System.GC]::GetTotalMemory($true)

# 方式三：List<T> + foreach —— 最佳性能
$list = [System.Collections.Generic.List[string]]::new()
$sw3 = [System.Diagnostics.Stopwatch]::StartNew()
foreach ($i in 1..$count) {
    if ($i % 2 -eq 0) {
        $list.Add("Item-$i")
    }
}
$sw3.Stop()
$time3 = $sw3.Elapsed.TotalMilliseconds
$mem3 = [System.GC]::GetTotalMemory($true)

# 输出对比结果
[PSCustomObject]@{
    '方式'         = '数组累加 (+=)'
    '耗时(ms)'     = [math]::Round($time1, 2)
    '结果数量'     = $result1.Count
} | Format-Table -AutoSize

[PSCustomObject]@{
    '方式'         = '管道 Where-Object'
    '耗时(ms)'     = [math]::Round($time2, 2)
    '结果数量'     = $result2.Count
} | Format-Table -AutoSize

[PSCustomObject]@{
    '方式'         = 'List<T> + foreach'
    '耗时(ms)'     = [math]::Round($time3, 2)
    '结果数量'     = $list.Count
} | Format-Table -AutoSize

Write-Host "`n结论: List<T> + foreach 最快，管道适中，数组累加最慢。"

# 流式处理大文件：逐行读取、过滤、输出，内存占用恒定
$logfile = "/var/log/system.log"

# 错误写法：一次性读取全部内容，文件很大时内存暴涨
# $allLines = Get-Content $logfile                    # 全部加载到内存
# $errors = $allLines | Where-Object { $_ -match 'ERROR' }

# 正确写法：使用 -ReadCount 0 让管道逐行流式处理
$sw = [System.Diagnostics.Stopwatch]::StartNew()
$errorCount = 0
$uniqueModules = [System.Collections.Generic.HashSet[string]]::new()

Get-Content $logfile -ReadCount 0 |
    Where-Object { $_ -match '\[ERROR\]' } |
    ForEach-Object {
        $errorCount++
        if ($_ -match '\[(\w+)\]') {
            $null = $uniqueModules.Add($Matches[1])
        }
        # 只输出前 5 条作为预览
        if ($errorCount -le 5) {
            $_
        }
    }

$sw.Stop()
Write-Host "`n--- 统计结果 ---"
Write-Host "扫描耗时: $($sw.Elapsed.TotalSeconds.ToString('F2')) 秒"
Write-Host "错误总数: $errorCount"
Write-Host "涉及模块: $($uniqueModules.Count) 个"
Write-Host "模块列表: $($uniqueModules -join ', ')"

# 流式处理 CSV 文件的技巧：使用 Import-Csv 配合管道
Write-Host "`n--- 流式 CSV 处理示例 ---"
$csvData = @"
Name,Department,Salary
Alice,Engineering,15000
Bob,Marketing,12000
Charlie,Engineering,18000
Diana,Marketing,11000
Eve,Engineering,20000
"@ | ConvertFrom-Csv

# 管道中间过滤，避免中间集合
$highEarners = $csvData |
    Where-Object { [int]$_.Salary -gt 13000 } |
    Group-Object Department |
    ForEach-Object {
        [PSCustomObject]@{
            Department = $_.Name
            Count      = $_.Count
            AvgSalary  = [math]::Round(($_.Group | Measure-Object -Property Salary -Average).Average, 0)
        }
    }

$highEarners | Format-Table -AutoSize

# 自定义管道函数：统计文本行信息的流式处理器
function Measure-TextStatistics {
    <#
    .SYNOPSIS
    流式统计文本的字符数、单词数和行数
    .PARAMETER InputObject
    通过管道传入的文本行
    #>
    [CmdletBinding()]
    param(
        [Parameter(Mandatory, ValueFromPipeline)]
        [string]$InputObject
    )

    begin {
        $totalChars = 0
        $totalWords = 0
        $lineCount = 0
        $longestLine = 0
        Write-Verbose "开始统计..."
    }

    process {
        $lineCount++
        $totalChars += $InputObject.Length
        $wordCount = ($InputObject -split '\s+').Where({ $_.Length -gt 0 }).Count
        $totalWords += $wordCount
        if ($InputObject.Length -gt $longestLine) {
            $longestLine = $InputObject.Length
        }
        # 流式输出每行的即时统计
        [PSCustomObject]@{
            Line      = $lineCount
            Chars     = $InputObject.Length
            Words     = $wordCount
            IsLong    = $InputObject.Length -gt 80
        }
    }

    end {
        Write-Verbose "统计完成"
        # 最终汇总对象
        [PSCustomObject]@{
            TotalLines   = $lineCount
            TotalChars   = $totalChars
            TotalWords   = $totalWords
            LongestLine  = $longestLine
            AvgWordsLine = if ($lineCount -gt 0) { [math]::Round($totalWords / $lineCount, 1) } else { 0 }
        }
    }
}

# 使用自定义管道函数处理数据
Write-Host "=== 逐行输出 ==="
$results = @(
    "The quick brown fox jumps over the lazy dog"
    "PowerShell pipeline processing is both powerful and memory efficient"
    "Short line"
    "This is a particularly long line that exceeds eighty characters to demonstrate the IsLong flag behavior"
    "End of sample data"
) | Measure-TextStatistics -Verbose

$results | Format-Table -AutoSize

Write-Host "`n=== 管道绑定参数示例 ==="
# 演示 ValueFromPipelineByPropertyName 属性绑定
function Get-ProcessedReport {
    [CmdletBinding()]
    param(
        [Parameter(Mandatory, ValueFromPipelineByPropertyName)]
        [string]$Name,

        [Parameter(ValueFromPipelineByPropertyName)]
        [int]$Salary,

        [int]$BonusPercent = 10
    )

    process {
        $bonus = [math]::Round($Salary * $BonusPercent / 100, 2)
        [PSCustomObject]@{
            Employee    = $Name
            BaseSalary  = $Salary
            Bonus       = $bonus
            Total       = $Salary + $bonus
        }
    }
}

# 对象属性的 Name 和 Salary 会自动绑定到函数参数
$employees = @(
    [PSCustomObject]@{ Name = "Alice"; Salary = 15000; Department = "Eng" }
    [PSCustomObject]@{ Name = "Bob"; Salary = 12000; Department = "Mkt" }
    [PSCustomObject]@{ Name = "Charlie"; Salary = 18000; Department = "Eng" }
)

$employees | Get-ProcessedReport -BonusPercent 15 | Format-Table -AutoSize

# 定义测试参数
$iterations = 1000
$arrayTimes = @()
$hashtableTimes = @()

for ($i = 1; $i -le $iterations; $i++) {
    # 测量数组追加操作
    $arrayTime = Measure-Command {
        $arr = @()
        foreach ($j in 1..500) {
            $arr += $j
        }
    }
    $arrayTimes += $arrayTime.TotalMilliseconds

    # 测量哈希表查找操作
    $ht = @{}
    foreach ($j in 1..500) {
        $ht[$j] = "value_$j"
    }
    $htTime = Measure-Command {
        $null = $ht[250]
    }
    $hashtableTimes += $htTime.TotalMilliseconds
}

# 计算平均耗时
$avgArray = ($arrayTimes | Measure-Object -Average).Average
$avgHash = ($hashtableTimes | Measure-Object -Average).Average

Write-Host ("数组追加 平均耗时: {0:N2} ms" -f $avgArray)
Write-Host ("哈希表查找 平均耗时: {0:N4} ms" -f $avgHash)

function Invoke-Benchmark {
    param(
        [hashtable]$Implementations,
        [int]$Iterations = 100
    )

    $results = @()

    foreach ($name in $Implementations.Keys) {
        $scriptBlock = $Implementations[$name]
        $timings = @()

        for ($i = 1; $i -le $Iterations; $i++) {
            $elapsed = Measure-Command -Expression $scriptBlock
            $timings += $elapsed.TotalMilliseconds
        }

        $stats = $timings | Measure-Object -Average -Minimum -Maximum

        $results += [PSCustomObject]@{
            Name     = $name
            AvgMs    = [math]::Round($stats.Average, 4)
            MinMs    = [math]::Round($stats.Minimum, 4)
            MaxMs    = [math]::Round($stats.Maximum, 4)
            Runs     = $Iterations
        }
    }

    # 按平均耗时排序并输出
    $results | Sort-Object AvgMs | Format-Table -AutoSize
}

# 定义三种字符串拼接方式的候选实现
$impls = @{
    '加号拼接' = {
        $s = ''
        foreach ($i in 1..200) {
            $s = $s + "item_$i"
        }
    }
    '格式化拼接' = {
        $s = ''
        foreach ($i in 1..200) {
            $s = '{0}{1}' -f $s, "item_$i"
        }
    }
    'StringBuilder' = {
        $sb = [System.Text.StringBuilder]::new()
        foreach ($i in 1..200) {
            $null = $sb.Append("item_$i")
        }
        $s = $sb.ToString()
    }
}

Invoke-Benchmark -Implementations $impls -Iterations 50

# 性能分析器的全局存储
$script:ProfileMarks = [System.Collections.Generic.List[PSObject]]::new()

function Start-ProfileBlock {
    param([string]$Label)
    $script:ProfileMarks.Add(
        [PSCustomObject]@{
            Label = $Label
            Time  = Get-Date
        }
    )
}

function Stop-ProfileSession {
    $totalMarks = $script:ProfileMarks.Count
    if ($totalMarks -lt 2) {
        Write-Warning "至少需要两个标记点才能计算耗时。"
        return
    }

    $segments = @()
    for ($i = 1; $i -lt $totalMarks; $i++) {
        $prev = $script:ProfileMarks[$i - 1]
        $curr = $script:ProfileMarks[$i]
        $duration = ($curr.Time - $prev.Time).TotalMilliseconds
        $segments += [PSCustomObject]@{
            Segment  = "$($prev.Label) -> $($curr.Label)"
            Label    = $prev.Label
            Duration = [math]::Round($duration, 2)
        }
    }

    $totalDuration = ($segments | Measure-Object -Property Duration -Sum).Sum

    foreach ($seg in $segments) {
        $seg | Add-Member -NotePropertyName 'Percent' `
              -NotePropertyValue ([math]::Round($seg.Duration / $totalDuration * 100, 1)) `
              -PassThru
    }

    $segments | Sort-Object Duration -Descending | Format-Table -AutoSize
    Write-Host ("总耗时: {0:N2} ms" -f $totalDuration)

    # 清理标记以便复用
    $script:ProfileMarks.Clear()
}

# ---- 模拟被分析的脚本 ----

Start-ProfileBlock -Label "开始"

# 第一段：读取 CSV 数据
$data = @(1..5000 | ForEach-Object {
    [PSCustomObject]@{
        Id     = $_
        Name   = "User_$_"
        Score  = Get-Random -Minimum 0 -Maximum 100
        Active = [bool](Get-Random -Minimum 0 -Maximum 2)
    }
})
Start-ProfileBlock -Label "数据生成"

# 第二段：过滤和排序
$filtered = @()
foreach ($item in $data) {
    if ($item.Active -and $item.Score -ge 50) {
        $filtered += $item
    }
}
$sorted = $filtered | Sort-Object Score -Descending
Start-ProfileBlock -Label "过滤排序"

# 第三段：输出报表
$report = $sorted | Select-Object -First 20 | Format-Table -AutoSize | Out-String
Write-Host $report
Start-ProfileBlock -Label "报表输出"

# 输出性能分析报告
Stop-ProfileSession

# 当前进程内存信息
$proc = Get-Process -Id $PID
Write-Host "PowerShell 进程内存分析" -ForegroundColor Cyan
Write-Host "  工作集 (Working Set):    $([math]::Round($proc.WorkingSet64 / 1MB, 2)) MB"
Write-Host "  专用字节 (Private Bytes): $([math]::Round($proc.PrivateMemorySize64 / 1MB, 2)) MB"
Write-Host "  虚拟内存:                $([math]::Round($proc.VirtualMemorySize64 / 1MB, 2)) MB"
Write-Host "  句柄数:                  $($proc.HandleCount)"
Write-Host "  线程数:                  $($proc.Threads.Count)"

# .NET CLR 内存统计
$heap = [GC]::GetTotalMemory($false)
Write-Host "`n.NET 堆内存：$([math]::Round($heap / 1MB, 2)) MB" -ForegroundColor Yellow

# GC 代数统计
Write-Host "`nGC 代数回收次数：" -ForegroundColor Cyan
Write-Host "  Gen 0: $([GC]::CollectionCount(0))"
Write-Host "  Gen 1: $([GC]::CollectionCount(1))"
Write-Host "  Gen 2: $([GC]::CollectionCount(2))"

# 内存消耗函数
function Measure-ScriptMemory {
    param([scriptblock]$ScriptBlock, [string]$Label = "Test")

    [GC]::Collect()
    [GC]::WaitForPendingFinalizers()
    $before = [GC]::GetTotalMemory($true)

    $sw = [System.Diagnostics.Stopwatch]::StartNew()
    & $ScriptBlock
    $sw.Stop()

    $after = [GC]::GetTotalMemory($false)
    $diff = $after - $before

    [PSCustomObject]@{
        Label     = $Label
        BeforeMB  = [math]::Round($before / 1MB, 2)
        AfterMB   = [math]::Round($after / 1MB, 2)
        DeltaMB   = [math]::Round($diff / 1MB, 2)
        TimeMs    = $sw.ElapsedMilliseconds
        Gen0      = [GC]::CollectionCount(0)
        Gen1      = [GC]::CollectionCount(1)
        Gen2      = [GC]::CollectionCount(2)
    }
}

# 对比不同方式的内存消耗
$result1 = Measure-ScriptMemory -Label "数组累加" -ScriptBlock {
    $arr = @()
    foreach ($i in 1..10000) { $arr += $i }
}

$result2 = Measure-ScriptMemory -Label "List 泛型" -ScriptBlock {
    $list = [System.Collections.Generic.List[int]]::new()
    foreach ($i in 1..10000) { $list.Add($i) }
}

$result3 = Measure-ScriptMemory -Label "赋值变量" -ScriptBlock {
    $result = foreach ($i in 1..10000) { $i }
}

"数组累加", "List 泛型", "赋值变量" | ForEach-Object {
    switch ($_) {
        "数组累加" { $result1 }
        "List 泛型" { $result2 }
        "赋值变量" { $result3 }
    }
} | Format-Table -AutoSize

# 大对象堆（LOH）分析
# 超过 85,000 字节的对象存储在 LOH 中，LOH 的回收代价很高
function Get-LargeObjectStats {
    # 使用 GC 内存信息
    $totalMemory = [GC]::GetTotalMemory($false)
    $heapSize = [System.AppDomain]::CurrentDomain.MonitoringTotalAllocatedMemorySize

    Write-Host "总分配内存：$([math]::Round($heapSize / 1MB, 2)) MB" -ForegroundColor Cyan
    Write-Host "当前存活内存：$([math]::Round($totalMemory / 1MB, 2)) MB" -ForegroundColor Yellow

    # 强制 GC 回收
    Write-Host "`n执行完整 GC 回收..." -ForegroundColor Yellow
    [GC]::Collect()
    [GC]::WaitForPendingFinalizers()
    [GC]::Collect()  # 二次回收确保 Finalizer 队列的对象被回收

    $afterGC = [GC]::GetTotalMemory($true)
    $freed = $totalMemory - $afterGC
    Write-Host "回收后内存：$([math]::Round($afterGC / 1MB, 2)) MB（释放 $([math]::Round($freed / 1MB, 2)) MB）" -ForegroundColor Green
}

Get-LargeObjectStats

# 处理大文件时的内存优化
function Get-LargeFileHashBatch {
    param(
        [string]$Path,
        [int]$BatchSize = 100
    )

    $files = [System.IO.Directory]::EnumerateFiles($Path, "*", [System.IO.SearchOption]::AllDirectories)
    $batch = @()
    $totalProcessed = 0

    foreach ($file in $files) {
        $info = [System.IO.FileInfo]::new($file)
        $hash = (Get-FileHash $file -Algorithm SHA256).Hash

        $batch += [PSCustomObject]@{
            File   = $info.Name
            SizeKB = [math]::Round($info.Length / 1KB, 2)
            Hash   = $hash.Substring(0, 16) + "..."
        }

        $totalProcessed++

        if ($batch.Count -ge $BatchSize) {
            # 输出批次结果并释放引用
            $batch
            $batch = @()

            if ($totalProcessed % 500 -eq 0) {
                [GC]::Collect()
                $mem = [math]::Round([GC]::GetTotalMemory($false) / 1MB, 2)
                Write-Host "  已处理 $totalProcessed 个文件，内存：$mem MB" -ForegroundColor DarkGray
            }
        }
    }

    # 输出最后一批
    if ($batch) { $batch }
    Write-Host "`n总计处理：$totalProcessed 个文件" -ForegroundColor Green
}

# 使用流式处理替代一次性加载
function Read-LargeCsvStreaming {
    param(
        [string]$Path,
        [int]$TopN = 10
    )

    $reader = [System.IO.StreamReader]::new($Path)
    $header = $reader.ReadLine()
    $columns = $header -split ','

    $count = 0
    while ($null -ne ($line = $reader.ReadLine()) -and $count -lt $TopN) {
        $values = $line -split ','
        $obj = [ordered]@{}
        for ($i = 0; $i -lt $columns.Count; $i++) {
            $obj[$columns[$i].Trim('"')] = $values[$i].Trim('"')
        }
        [PSCustomObject]$obj
        $count++
    }

    $reader.Close()
    $reader.Dispose()
}

Write-Host "`n流式处理避免了将整个文件加载到内存" -ForegroundColor Green

# 脚本性能分析器
function Measure-ScriptPerformance {
    param(
        [Parameter(Mandatory)]
        [scriptblock]$ScriptBlock,

        [int]$Iterations = 3
    )

    $results = @()

    # 预热（排除 JIT 编译影响）
    Write-Host "预热中..." -ForegroundColor DarkGray
    & $ScriptBlock | Out-Null

    for ($i = 1; $i -le $Iterations; $i++) {
        [GC]::Collect()
        [GC]::WaitForPendingFinalizers()

        $memBefore = [GC]::GetTotalMemory($true)
        $sw = [System.Diagnostics.Stopwatch]::StartNew()

        & $ScriptBlock | Out-Null

        $sw.Stop()
        $memAfter = [GC]::GetTotalMemory($false)

        $results += [PSCustomObject]@{
            Iteration = $i
            TimeMs    = $sw.ElapsedMilliseconds
            MemoryKB  = [math]::Round(($memAfter - $memBefore) / 1KB, 2)
            Gen0      = [GC]::CollectionCount(0)
        }

        Write-Host "  第 $i 次：$($sw.ElapsedMilliseconds) ms" -ForegroundColor DarkGray
    }

    $avg = ($results | Measure-Object TimeMs -Average).Average
    $min = ($results | Measure-Object TimeMs -Minimum).Minimum
    $max = ($results | Measure-Object TimeMs -Maximum).Maximum

    Write-Host "`n性能统计：" -ForegroundColor Cyan
    Write-Host "  平均：$([math]::Round($avg, 2)) ms"
    Write-Host "  最快：$min ms"
    Write-Host "  最慢：$max ms"

    return $results
}

# 对比字符串拼接方式
Write-Host "=== 字符串拼接对比 ===" -ForegroundColor Yellow

Measure-ScriptPerformance -Iterations 3 -ScriptBlock {
    $s = ""
    foreach ($i in 1..1000) { $s += "Line $i`n" }
} | Out-Null

Measure-ScriptPerformance -Iterations 3 -ScriptBlock {
    $sb = [System.Text.StringBuilder]::new()
    foreach ($i in 1..1000) { $sb.AppendLine("Line $i") | Out-Null }
    $sb.ToString()
} | Out-Null

# 基本并行用法（PowerShell 7+）
$servers = @("SRV01", "SRV02", "SRV03", "SRV04", "SRV05")

# 串行获取磁盘信息
$sw = [System.Diagnostics.Stopwatch]::StartNew()
$serial = foreach ($server in $servers) {
    Invoke-Command -ComputerName $server -ScriptBlock {
        Get-PSDrive -PSProvider FileSystem | Select-Object Name,
            @{N='FreeGB'; E={[math]::Round($_.Free / 1GB, 2)}},
            @{N='UsedGB'; E={[math]::Round($_.Used / 1GB, 2)}}
    }
}
$sw.Stop()
Write-Host "串行执行：$($sw.ElapsedMilliseconds) ms"

# 并行获取磁盘信息
$sw.Restart()
$parallel = $servers | ForEach-Object -ThrottleLimit 5 -Parallel {
    Invoke-Command -ComputerName $_ -ScriptBlock {
        Get-PSDrive -PSProvider FileSystem | Select-Object Name,
            @{N='FreeGB'; E={[math]::Round($_.Free / 1GB, 2)}},
            @{N='UsedGB'; E={[math]::Round($_.Used / 1GB, 2)}}
    }
}
$sw.Stop()
Write-Host "并行执行：$($sw.ElapsedMilliseconds) ms"

# 带返回值的并行处理
$results = 1..100 | ForEach-Object -ThrottleLimit 10 -Parallel {
    # 模拟耗时计算
    Start-Sleep -Milliseconds 50
    [PSCustomObject]@{
        Input   = $_
        Squared = $_ * $_
        Thread  = [System.Threading.Thread]::CurrentThread.ManagedThreadId
    }
}

$uniqueThreads = $results.Thread | Sort-Object -Unique
Write-Host "使用了 $($uniqueThreads.Count) 个线程处理 100 个任务"
$results | Select-Object -First 5 | Format-Table -AutoSize

# 向并行代码块传递变量
$threshold = 80
$warningEmail = "admin@contoso.com"

$drives = @(
    @{ Server = "SRV01"; Drive = "C:" },
    @{ Server = "SRV02"; Drive = "D:" },
    @{ Server = "SRV03"; Drive = "C:" }
)

$alerts = $drives | ForEach-Object -ThrottleLimit 3 -Parallel {
    # 使用 $using: 引用外部变量
    $thresh = $using:threshold
    $email  = $using:warningEmail

    # 模拟获取磁盘使用率
    $usage = Get-Random -Minimum 50 -Maximum 100

    if ($usage -gt $thresh) {
        [PSCustomObject]@{
            Server    = $_.Server
            Drive     = $_.Drive
            Usage     = $usage
            Alert     = "$($_.Server) $($_.Drive) 使用率 ${usage}% 超过阈值 ${thresh}%"
            NotifyTo  = $email
        }
    }
}

if ($alerts) {
    Write-Host "磁盘告警：" -ForegroundColor Red
    $alerts | Format-Table Server, Drive, Usage, Alert -AutoSize
} else {
    Write-Host "所有磁盘使用率正常" -ForegroundColor Green
}

# 使用 ConcurrentDictionary 共享状态（线程安全）
$counter = [System.Collections.Concurrent.ConcurrentDictionary[string, int]]::new()

1..50 | ForEach-Object -ThrottleLimit 10 -Parallel {
    $dict = $using:counter
    $category = @("Web", "API", "DB", "Cache")[(Get-Random -Minimum 0 -Maximum 4)]
    $dict.AddOrUpdate($category, 1, { param($k, $v) $v + 1 })
}

Write-Host "`n分类统计：" -ForegroundColor Cyan
$counter.GetEnumerator() | Sort-Object Value -Descending |
    ForEach-Object { Write-Host "  $($_.Key): $($_.Value)" }

# PowerShell 5.1 兼容的并行方案
function Invoke-RunspaceJob {
    param(
        [Parameter(Mandatory)]
        [scriptblock]$ScriptBlock,

        [Parameter(Mandatory)]
        [object[]]$InputData,

        [int]$ThrottleLimit = 4
    )

    $pool = [runspacefactory]::CreateRunspacePool(1, $ThrottleLimit)
    $pool.Open()

    $jobs = [System.Collections.Generic.List[hashtable]]::new()

    foreach ($item in $InputData) {
        $ps = [powershell]::Create()
        $ps.RunspacePool = $pool

        # 添加脚本和参数
        $ps.AddScript($ScriptBlock).AddArgument($item) | Out-Null

        $jobs.Add(@{
            PowerShell = $ps
            Handle     = $ps.BeginInvoke()
            Input      = $item
        })
    }

    # 等待所有任务完成
    $results = @()
    foreach ($job in $jobs) {
        try {
            $output = $job.PowerShell.EndInvoke($job.Handle)
            if ($output) { $results += $output }
        } catch {
            Write-Host "任务失败：$($job.Input) - $($_.Exception.Message)" -ForegroundColor Red
        } finally {
            $job.PowerShell.Dispose()
        }
    }

    $pool.Close()
    $pool.Dispose()

    return $results
}

# 使用 Runspace 并行 Ping 测试
$computers = @(
    "SRV01", "SRV02", "SRV03", "SRV04", "SRV05",
    "DB01", "DB02", "WEB01", "WEB02", "APP01"
)

$pingResults = Invoke-RunspaceJob -InputData $computers -ThrottleLimit 5 -ScriptBlock {
    param([string]$Computer)

    $sw = [System.Diagnostics.Stopwatch]::StartNew()
    $ping = Test-Connection -ComputerName $Computer -Count 1 -Quiet -ErrorAction SilentlyContinue
    $sw.Stop()

    [PSCustomObject]@{
        Computer  = $Computer
        Online    = $ping
        LatencyMs = $sw.ElapsedMilliseconds
    }
}

$pingResults | Sort-Object Computer | Format-Table -AutoSize

$online = ($pingResults | Where-Object { $_.Online }).Count
Write-Host "在线：$online / $($computers.Count)" -ForegroundColor Green

# 并行处理大量文件
function Invoke-ParallelFileProcess {
    param(
        [Parameter(Mandatory)]
        [string]$Path,

        [Parameter(Mandatory)]
        [scriptblock]$ProcessBlock,

        [string]$Filter = "*.*",
        [int]$ThrottleLimit = 4
    )

    $files = Get-ChildItem $Path -Filter $Filter -File
    Write-Host "找到 $($files.Count) 个文件，使用 $ThrottleLimit 并发处理" -ForegroundColor Cyan

    $sw = [System.Diagnostics.Stopwatch]::StartNew()

    $results = $files | ForEach-Object -ThrottleLimit $ThrottleLimit -Parallel {
        $file = $_
        $block = $using:ProcessBlock

        try {
            & $block $file
        } catch {
            [PSCustomObject]@{
                File  = $file.Name
                Error = $_.Exception.Message
                Status = "Failed"
            }
        }
    }

    $sw.Stop()

    $success = ($results | Where-Object { $_.Status -ne "Failed" }).Count
    $failed  = ($results | Where-Object { $_.Status -eq "Failed" }).Count

    Write-Host "`n处理完成：成功 $success，失败 $failed" -ForegroundColor $(if ($failed) { "Yellow" } else { "Green" })
    Write-Host "耗时：$($sw.ElapsedMilliseconds) ms"

    return $results
}

# 示例：批量计算文件哈希
$hashResults = Invoke-ParallelFileProcess -Path "C:\Projects\MyApp\bin" -Filter "*.dll" -ThrottleLimit 8 -ProcessBlock {
    param($file)
    $hash = (Get-FileHash $file.FullName -Algorithm SHA256).Hash
    [PSCustomObject]@{
        File   = $file.Name
        SizeKB = [math]::Round($file.Length / 1KB, 2)
        SHA256 = $hash.Substring(0, 16) + "..."
        Status = "OK"
    }
}

$hashResults | Format-Table -AutoSize

# 测量不同方式的性能差异
$items = 1..100000

# 方式 1：管道 + ForEach-Object
$sw = [System.Diagnostics.Stopwatch]::StartNew()
$result1 = $items | ForEach-Object { $_ * 2 }
$sw.Stop()
Write-Host "管道 ForEach-Object：$($sw.ElapsedMilliseconds) ms，结果数：$($result1.Count)"

# 方式 2：赋值变量 + foreach 语句
$sw.Restart()
$result2 = foreach ($item in $items) { $item * 2 }
$sw.Stop()
Write-Host "foreach 语句：$($sw.ElapsedMilliseconds) ms，结果数：$($result2.Count)"

# 方式 3：LINQ（PowerShell 7+）
$sw.Restart()
$result3 = [System.Linq.Enumerable]::Select(
    [int[]]$items, [Func[int, int]]{ param($x) $x * 2 }
)
$sw.Stop()
Write-Host "LINQ Select：$($sw.ElapsedMilliseconds) ms，结果数：$($result3.Count)"

# 方式 4：List 累积器
$sw.Restart()
$list = [System.Collections.Generic.List[int]]::new($items.Count)
foreach ($item in $items) { $list.Add($item * 2) }
$sw.Stop()
Write-Host "List 累积器：$($sw.ElapsedMilliseconds) ms，结果数：$($list.Count)"