Kotlin线程池newFixedThreadPoolContext与约束协程运行的线程数量limitedParallelism

Kotlin线程池newFixedThreadPoolContext与约束协程运行的线程数量limitedParallelism

import kotlinx.coroutines.async
import kotlinx.coroutines.delay
import kotlinx.coroutines.newFixedThreadPoolContext
import kotlinx.coroutines.runBlocking

fun main() {
    runBlocking {
        //应用全局协的总线程数量
        val MAX_SIZE = 4
        val allDispatcher = newFixedThreadPoolContext(MAX_SIZE, "全局")

        //val limitedDispatchers=Dispatchers.Default.limitedParallelism(MAX_SIZE)
        //launch(limitedDispatchers){
        //}

        val SLEEP_TIME = 1L

        //假设有一个高优先级任务hightTask，最多可以跑在MAX_SIZE个线程中。
        //只要MAX_SIZE个线程中任何一个线程有空闲，就可以调度运行。
        val highTask = allDispatcher.limitedParallelism(MAX_SIZE)
        async(highTask) {
            repeat(Int.MAX_VALUE) {
                println("high tid=${Thread.currentThread().name}")
                delay(SLEEP_TIME)
            }
        }

        //假设有一个中等优先级任务的mediumTask，最多可以跑在2个线程中。
        //只要MAX_SIZE-2个线程中任何一个线程有空闲，就可以调度运行。
        val mediumTask = allDispatcher.limitedParallelism(MAX_SIZE - 2)
        async(mediumTask) {
            repeat(Int.MAX_VALUE) {
                println("medium tid=${Thread.currentThread().name}")
                delay(SLEEP_TIME)
            }
        }

        //假设有一个低等优先级任务的lowTask，最多可以跑在1个线程中。
        //只要MAX_SIZE-3个线程中任何一个线程有空闲，就可以调度运行。
        val lowTask = allDispatcher.limitedParallelism(MAX_SIZE - 3)
        async(lowTask) {
            repeat(Int.MAX_VALUE) {
                println("low tid=${Thread.currentThread().name}")
                delay(SLEEP_TIME)
            }
        }
    }
}