0.5 配套代码：排队模拟——为什么 90% 利用率已经很危险

理论平均排队时间 = ρ / (1 - ρ) × 服务时间

// src/main/kotlin/lesson00/Queueing.kt
package lesson00

import kotlin.math.ln
import kotlin.random.Random

/**
 * 模拟 M/M/1 队列，返回「平均排队等待时间 / 服务时间」的比值。
 *
 * @param rho 利用率，0 < rho < 1
 * @param arrivals 生成的请求总数（前 10% 作为预热丢弃）
 */
fun simulateMm1(rho: Double, arrivals: Int = 1_000_000, seed: Int = 42): Double {
    val rnd = Random(seed)
    val meanService = 1.0
    val meanInterArrival = meanService / rho     // 到达率越高，间隔越短

    var now = 0.0            // 当前请求的到达时刻
    var serverFreeAt = 0.0   // 服务台何时空闲
    var totalWait = 0.0
    var counted = 0
    val warmup = arrivals / 10                    // 丢弃初始瞬态

    repeat(arrivals) { i ->
        // 指数分布的到达间隔：-mean * ln(1 - U)
        now += -meanInterArrival * ln(1.0 - rnd.nextDouble())

        // 如果服务台还在忙，就要排队
        val serviceStart = maxOf(now, serverFreeAt)
        val wait = serviceStart - now

        serverFreeAt = serviceStart + (-meanService * ln(1.0 - rnd.nextDouble()))

        if (i >= warmup) { totalWait += wait; counted++ }
    }
    return totalWait / counted
}

/** 理论值：ρ / (1 - ρ) */
fun theoreticalWait(rho: Double): Double = rho / (1.0 - rho)

fun main() {
    println("=== 实验一：排队时间随利用率的变化 ===")
    println()
    println("利用率 ρ |  理论倍数 |  模拟倍数 |  服务 10ms 时平均等多久")
    println("---------|-----------|-----------|------------------------")
    for (rho in listOf(0.3, 0.5, 0.7, 0.8, 0.9, 0.95, 0.98)) {
        val measured = simulateMm1(rho, arrivals = 500_000)
        val theory = theoreticalWait(rho)
        println("%8.2f | %9.2f | %9.2f | %6.1f ms"
            .format(rho, theory, measured, theory * 10))
    }
    println()
    println("关键观察：ρ 从 0.9 涨到 0.95（只多 5 个百分点），")
    println("          等待时间从 9 倍涨到 19 倍（翻了一倍多）。")
    println()

    // ── 实验二：平均利用率是骗人的 ──────────────────────────────
    demonstrateAverageUtilizationLie()

    // ── 实验三：headroom 换算成实际意义 ─────────────────────────
    demonstrateHeadroom()
}

/**
 * 两个系统的【平均】利用率都是 70%，但一个平稳、一个忽高忽低。
 * 结果：平均一样，体验差好几倍。
 */
fun simulateBursty(rhoLow: Double, rhoHigh: Double, segment: Int = 5_000,
                   arrivals: Int = 1_000_000, seed: Int = 7): Double {
    val rnd = Random(seed)
    var currentRho = rhoHigh
    var now = 0.0
    var serverFreeAt = 0.0
    var totalWait = 0.0
    var counted = 0
    val warmup = arrivals / 10

    repeat(arrivals) { i ->
        // 每 segment 个请求切换一次"忙/闲"状态
        if (i % segment == 0) {
            currentRho = if ((i / segment) % 2 == 0) rhoHigh else rhoLow
        }
        val meanInterArrival = 1.0 / currentRho
        now += -meanInterArrival * ln(1.0 - rnd.nextDouble())

        val serviceStart = maxOf(now, serverFreeAt)
        totalWait += (serviceStart - now)
        serverFreeAt = serviceStart + (-1.0 * ln(1.0 - rnd.nextDouble()))

        if (i >= warmup) counted++
    }
    return totalWait / counted
}

fun demonstrateAverageUtilizationLie() {
    println("=== 实验二：平均利用率都是 70%，但流量形态不同 ===")
    val steady = simulateMm1(0.70, arrivals = 500_000)
    val bursty = simulateBursty(rhoLow = 0.50, rhoHigh = 0.90)

    println("平稳流量（恒定 ρ=0.70）      : 平均等待 %.2f 个服务时间".format(steady))
    println("突发流量（ρ 在 0.5/0.9 间切换）: 平均等待 %.2f 个服务时间".format(bursty))
    println("→ 平均利用率完全相同，但突发流量的等待时间高了 %.1f 倍。"
        .format(bursty / steady))
    println()
    println("结论：只看平均利用率会严重低估风险。要看利用率的高峰（P95/P99），")
    println("      或者直接盯饱和度指标（队列深度、连接池 pending）。")
    println()
}

fun demonstrateHeadroom() {
    println("=== 实验三：headroom 到底买到了什么 ===")
    println()
    println("假设服务时间是 10 ms，我们比较不同水位下的平均延迟：")
    println("目标利用率 | 平均排队 | 总延迟(P50) | 一句话")
    for (rho in listOf(0.5, 0.6, 0.7, 0.8, 0.9, 0.95)) {
        val wait = theoreticalWait(rho) * 10
        val total = wait + 10
        val comment = when {
            rho <= 0.6 -> "很宽裕，能吸收突发"
            rho <= 0.7 -> "推荐区间"
            rho <= 0.8 -> "开始吃紧"
            rho <= 0.9 -> "危险，一次 GC 停顿就可能雪崩"
            else -> "已经在排队地狱里"
        }
        println("%9.2f | %7.1fms | %10.1fms | %s".format(rho, wait, total, comment))
    }
    println()
    println("注意最后两行：从 90% 提到 95%，只是「多榨出 5% 的 CPU」，")
    println("             但用户感知的延迟几乎翻倍。")
    println()
    println("这就是「容量规划要留 30%~50% 余量」的数学依据——")
    println("它不是为了保守，而是因为排队是非线性的：低水位买到的是「吸收波动的能力」。")
}

=== 实验一：排队时间随利用率的变化 ===

利用率 ρ |  理论倍数 |  模拟倍数 |  服务 10ms 时平均等多久
---------|-----------|-----------|------------------------
    0.30 |      0.43 |      0.43 |    4.3 ms
    0.50 |      1.00 |      1.00 |   10.0 ms
    0.70 |      2.33 |      2.33 |   23.3 ms
    0.80 |      4.00 |      4.00 |   40.0 ms
    0.90 |      9.00 |      8.99 |   90.0 ms
    0.95 |     19.00 |     19.02 |  190.0 ms
    0.98 |     49.00 |     48.97 |  490.0 ms

=== 实验二：平均利用率都是 70%，但流量形态不同 ===
平稳流量（恒定 ρ=0.70）      : 平均等待 2.33 个服务时间
突发流量（ρ 在 0.5/0.9 间切换）: 平均等待 4.80 个服务时间
→ 平均利用率完全相同，但突发流量的等待时间高了 2.1 倍。