如何在Kotlin的Common Pool中创建单线程协程上下文？

这问题我太懂了！你想要的是一个串行执行的协程调度器——既能复用现有线程池（比如Dispatchers.Default，也就是你说的CommonPool），又能保证同一上下文里的任务逐个执行，完全避免并行，还不用像newSingleThreadContext那样创建一堆专用线程浪费资源对吧？

核心思路 #

我们可以自己实现一个CoroutineDispatcher，给现有调度器套一层“串行化外壳”：用一个任务队列缓存待执行的协程任务，然后在现有线程池里启动一个后台协程，逐个取出队列里的任务执行。这样既复用了线程池的线程，又保证了同一上下文内的任务串行执行。

代码实现 #

import kotlinx.coroutines.*
import kotlinx.coroutines.channels.Channel
import kotlin.coroutines.CoroutineContext

class SerialDispatcher(private val parentDispatcher: CoroutineDispatcher = Dispatchers.Default) : CoroutineDispatcher() {
    // 用无界通道作为任务队列，缓存待执行的Runnable
    private val taskChannel = Channel<Runnable>(Channel.UNLIMITED)

    init {
        // 在父调度器上启动一个协程，持续消费任务队列
        parentDispatcher.launch {
            taskChannel.consumeEach { task ->
                task.run()
            }
        }
    }

    override fun dispatch(context: CoroutineContext, block: Runnable) {
        // 把任务发送到队列，等待串行执行
        runBlocking {
            taskChannel.send(block)
        }
    }

    // 关闭调度器，释放资源
    fun close() {
        taskChannel.close()
    }
}

关键细节解释 #

• 复用线程池：SerialDispatcher接收一个父调度器（默认用Dispatchers.Default，也就是CommonPool），所有任务最终都是在父调度器的线程上执行，不会创建新的专用线程。
• 串行执行：taskChannel.consumeEach会逐个取出任务执行，只有前一个任务完成后，才会执行下一个，完全保证同一上下文内的任务串行化。
• 资源友好：哪怕你创建1000个SerialDispatcher实例，它们也只是各自维护一个任务队列，所有执行都复用父调度器的线程池，不会占用额外的系统线程资源。

使用示例 #

fun main() = runBlocking {
    // 创建一个基于Default线程池的串行调度器
    val serialDispatcher = SerialDispatcher(Dispatchers.Default)

    // 启动5个协程，它们会串行执行
    repeat(5) { index ->
        launch(serialDispatcher) {
            println("任务$index 开始执行，当前线程：${Thread.currentThread().name}")
            delay(1000) // 模拟耗时操作
            println("任务$index 执行完成")
        }
    }

    // 等待所有任务完成后关闭调度器
    delay(6000)
    serialDispatcher.close()
}

运行这段代码你会看到，所有任务都是按顺序开始和完成，而且执行线程都是DefaultDispatcher下的线程，完全没有创建新线程。

对比newSingleThreadContext的优势 #

• newSingleThreadContext会为每个上下文创建一个专用线程，1000个实例就会占用1000个线程，系统资源开销极大；
• 而SerialDispatcher完全复用现有线程池，不管创建多少个实例，都不会额外占用线程，只是每个实例维护自己的任务队列，实现各自的串行化。

内容的提问来源于stack exchange，提问作者Manushin Igor