# 定义需要检查的服务器列表
$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()

# Start-Job：在后台运行脚本块
$job = Start-Job -ScriptBlock {
    Start-Sleep -Seconds 2
    Get-Process | Select-Object Name, Id, CPU | Sort-Object CPU -Descending | Select-Object -First 5
}

Write-Host "作业已启动，ID：$($job.Id)" -ForegroundColor Cyan

# 非阻塞检查状态
while ($job.State -eq 'Running') {
    Write-Host "." -NoNewline
    Start-Sleep -Milliseconds 500
}
Write-Host

# 获取结果
$result = Receive-Job -Job $job
Write-Host "作业完成，结果："
$result | Format-Table -AutoSize

# 清理作业
Remove-Job -Job $job

# 批量后台作业
$servers = @("SRV01", "SRV02", "SRV03", "SRV04", "SRV05")
$jobs = foreach ($server in $servers) {
    Start-Job -ScriptBlock {
        param($computer)
        $os = Get-CimInstance Win32_OperatingSystem -ComputerName $computer -ErrorAction SilentlyContinue
        if ($os) {
            [PSCustomObject]@{
                Server  = $computer
                OS      = $os.Caption
                Version = $os.Version
                Status  = "Online"
            }
        } else {
            [PSCustomObject]@{
                Server  = $computer
                OS      = "N/A"
                Version = "N/A"
                Status  = "Offline"
            }
        }
    } -ArgumentList $server
}

Write-Host "启动了 $($jobs.Count) 个后台作业" -ForegroundColor Cyan

# 等待所有作业完成
$jobs | Wait-Job | Out-Null

# 收集所有结果
$allResults = $jobs | Receive-Job
$allResults | Format-Table -AutoSize

# 清理
$jobs | Remove-Job

# PowerShell 7 并行执行（推荐方式）
$servers = @("SRV01", "SRV02", "SRV03", "SRV04", "SRV05", "SRV06", "SRV07", "SRV08")

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

$results = $servers | ForEach-Object -Parallel {
    $server = $_
    try {
        $response = Invoke-WebRequest -Uri "http://${server}:8080/health" `
            -TimeoutSec 5 -UseBasicParsing -ErrorAction Stop
        [PSCustomObject]@{
            Server    = $server
            Status    = "Healthy"
            Code      = $response.StatusCode
            LatencyMs = $response.RawContentLength
        }
    } catch {
        [PSCustomObject]@{
            Server    = $server
            Status    = "Unhealthy"
            Code      = 0
            LatencyMs = 0
            Error     = $_.Exception.Message
        }
    }
} -ThrottleLimit 4

$sw.Stop()

$results | Format-Table -AutoSize
Write-Host "并行检查 8 台服务器耗时：$($sw.ElapsedMilliseconds)ms" -ForegroundColor Green

# 共享变量（需要 $using:）
$threshold = 80
$results = $servers | ForEach-Object -Parallel {
    $server = $_
    $cpu = Get-Random -Min 10 -Max 95
    [PSCustomObject]@{
        Server   = $server
        CPU      = $cpu
        IsAlert  = $cpu -gt $using:threshold
    }
} -ThrottleLimit 4

$results | Where-Object { $_.IsAlert } | Format-Table -AutoSize

function Invoke-Parallel {
    <#
    .SYNOPSIS
    使用 Runspace 池并行执行脚本块
    #>
    param(
        [Parameter(Mandatory)]
        [scriptblock]$ScriptBlock,

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

        [int]$ThrottleLimit = 4
    )

    # 创建 Runspace 池
    $pool = [System.Management.Automation.Runspaces.RunspaceFactory]::CreateRunspacePool(
        1, $ThrottleLimit
    )
    $pool.Open()

    $runspaces = @()

    foreach ($item in $InputData) {
        $powershell = [System.Management.Automation.PowerShell]::Create()
        $powershell.RunspacePool = $pool

        $null = $powershell.AddScript($ScriptBlock).AddArgument($item)

        $runspaces += [PSCustomObject]@{
            Pipe   = $powershell
            Handle = $powershell.BeginInvoke()
            Input  = $item
        }
    }

    # 等待完成并收集结果
    $results = @()
    foreach ($rs in $runspaces) {
        try {
            $output = $rs.Pipe.EndInvoke($rs.Handle)
            if ($output) {
                foreach ($o in $output) {
                    $results += $o
                }
            }
        } catch {
            $results += [PSCustomObject]@{
                Error  = $true
                Input  = $rs.Input
                Message = $_.Exception.Message
            }
        } finally {
            $rs.Pipe.Dispose()
        }
    }

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

    return $results
}

# 使用 Runspace 池并行 ping
$servers = 1..20 | ForEach-Object { "192.168.1.$_" }

$sw = [System.Diagnostics.Stopwatch]::StartNew()
$results = Invoke-Parallel -ScriptBlock {
    param($ip)
    $ping = Test-Connection -ComputerName $ip -Count 1 -Quiet -ErrorAction SilentlyContinue
    [PSCustomObject]@{ IP = $ip; Online = $ping }
} -InputData $servers -ThrottleLimit 10
$sw.Stop()

$online = ($results | Where-Object { $_.Online }).Count
Write-Host "扫描 20 个 IP，$online 个在线，耗时：$($sw.ElapsedMilliseconds)ms" -ForegroundColor Green
$results | Where-Object { $_.Online } | Format-Table -AutoSize

# 并行处理文件
$files = Get-ChildItem "C:\Logs" -Filter "*.log" -Recurse | Select-Object -First 20

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

$fileStats = $files | ForEach-Object -Parallel {
    $file = $_
    $lines = 0
    $errors = 0

    $reader = [System.IO.StreamReader]::new($file.FullName)
    while ($null -ne $reader.ReadLine()) {
        $lines++
    }
    $reader.Close()

    [PSCustomObject]@{
        Name     = $file.Name
        SizeKB   = [math]::Round($file.Length / 1KB, 1)
        Lines    = $lines
        Modified = $file.LastWriteTime.ToString('yyyy-MM-dd HH:mm')
    }
} -ThrottleLimit 4

$sw.Stop()

$fileStats | Format-Table -AutoSize
Write-Host "并行处理 $($files.Count) 个文件耗时：$($sw.ElapsedMilliseconds)ms" -ForegroundColor Green