0.1 配套代码：同一个函数，为什么测出三个不同的数字

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

import java.util.concurrent.CountDownLatch
import kotlin.concurrent.thread
import kotlin.system.measureNanoTime

/** 共享的「热点数据」，用于制造锁竞争 */
private val lock = Any()
private var sharedCounter = 0L

/**
 * 被测函数：模拟一次「有点计算量 + 需要访问共享资源」的操作。
 * 注意它是完全相同的代码，三种场景下不做任何修改。
 */
fun handleRequest(seed: Int): Long {
    // ① 一点本地计算（模拟业务逻辑）
    var local = seed.toLong()
    repeat(200) { local = local * 31 + it }

    // ② 访问共享资源（模拟写指标、更新缓存、计数器）
    synchronized(lock) {
        sharedCounter += local and 0xFF
        local += sharedCounter and 0x0F
    }

    // ③ 一点分配（模拟对象创建、序列化缓冲）
    val payload = ByteArray(256)
    payload[0] = local.toByte()
    return local + payload.size
}

/** 场景 A：单线程、无竞争 —— 这就是典型微基准会报告的"性能" */
fun scenarioA(iterations: Int): Long {
    waitForJit(iterations)
    return measureNanoTime {
        var sink = 0L
        repeat(iterations) { sink += handleRequest(it) }
        check(sink != Long.MIN_VALUE)
    } / iterations
}

/** 场景 B：8 线程争用同一把锁 */
fun scenarioB(iterations: Int, threads: Int = 8): Long {
    waitForJit(iterations)
    val perThread = iterations / threads
    val start = CountDownLatch(1)
    val done = CountDownLatch(threads)
    var totalElapsed = 0L

    repeat(threads) {
        thread {
            start.await()
            val elapsed = measureNanoTime {
                var sink = 0L
                repeat(perThread) { sink += handleRequest(it) }
                check(sink != Long.MIN_VALUE)
            }
            synchronized(lock) { totalElapsed = maxOf(totalElapsed, elapsed) }
            done.countDown()
        }
    }
    start.countDown()
    done.await()
    // 每个线程各自跑了 perThread 次，用时约等于最慢那个线程的耗时
    return totalElapsed / perThread
}

/** 场景 C：单线程，但持续分配大对象，制造 GC 压力 */
fun scenarioC(iterations: Int): Long {
    waitForJit(iterations)
    val garbage = ArrayList<ByteArray>(4096)
    return measureNanoTime {
        var sink = 0L
        repeat(iterations) { i ->
            sink += handleRequest(i)
            garbage.add(ByteArray(4096))          // 每秒产生大量垃圾
            if (garbage.size > 4096) garbage.clear()
        }
        check(sink != Long.MIN_VALUE)
    } / iterations
}

/** 预热：让 JIT 完成编译，否则测到的是解释执行阶段 */
private fun waitForJit(iterations: Int) {
    var sink = 0L
    repeat(iterations / 2) { sink += handleRequest(it) }
    check(sink != Long.MIN_VALUE)
}

fun main() {
    val n = 200_000
    println("同一个 handleRequest()，三种环境下运行：\n")
    println("A 单线程无竞争      : %6d ns/op".format(scenarioA(n)))
    println("B 8 线程争用同一把锁 : %6d ns/op".format(scenarioB(n)))
    println("C 单线程 + 分配压力  : %6d ns/op".format(scenarioC(n)))
    println("\n注意：三行是同一段代码。差别只来自运行环境。")
}

同一个 handleRequest()，三种环境下运行：

A 单线程无竞争      :     82 ns/op
B 8 线程争用同一把锁 :   1840 ns/op
C 单线程 + 分配压力  :    260 ns/op

注意：三行是同一段代码。差别只来自运行环境。