Add priority hint for CoroutineDispatchers

It will be useful for the tasks which depend on the quality of service. For example, we have N abstract clients using the common thread pool via CoroutineDispatcher. In rare moments a few clients have tasks with high priority to execution and they should be computed as soon as possible. Note: If we create multiple pools for each priority, the situation will turn out that if there are no tasks with a certain priority, some pools will be idle while others may be overloaded.

I guess, that the problem can be solved like that:

1. Create new CoroutineContextElement (for example, CoroutinePriority);
2. If CoroutinePriority is provided by CoroutineContext, wrap a dispatched task into an object which can be compared by taken priority and put it into the executor.

The new context element can thus be used:

launch(Dispatchers.Default + CoroutinePriority(42)) {
    ...
}

The element behaves like a hint. It works only in cases when the dispatcher created from custom thread pool with PriorityQueue and the priority is provided by context, so it produces no overhead in the other cases.

Unfortunately, the most of classes related with Dispatchers are internal in the coroutines package, so it isn’t possible to create this logic outside the coroutines library without pain. The another possible solution is to provide the extended API.

[elizarov]

You don’t really need to maintain all the internals. Look, a dispatcher implementation can be as simple as that:

class MyDispatcher : CoroutineDispatcher() {
    private val executor = Executors.newCachedThreadPool() // or anything else

    override fun dispatch(context: CoroutineContext, block: Runnable) =
        executor.execute(block)
}

[Richie94]

Hey, Im having the same request and wanted to have on one hand some validation that this is how it should be written and on the other hand to have some online example to copy.

class PriorityExecutor {

    private val priorityDispatcher = PriorityDispatcher()

    internal class PriorityDispatcher : CoroutineDispatcher() {

        private val priorityExecutor = ThreadPoolExecutor(
            1, 1, 0L, TimeUnit.MILLISECONDS, PriorityBlockingQueue(100000),
            CustomizableThreadFactory("importRunner-serializer")
        )

        override fun dispatch(context: CoroutineContext, block: Runnable) {
            val priority = context[CoroutinePriority]?.priority ?: 0
            val executable = RunWithPriorityFuture(RunWithPriority(block, priority))
            priorityExecutor.execute(executable)
        }

    }

    internal data class CoroutinePriority(
        val priority: Int
    ) : AbstractCoroutineContextElement(CoroutinePriority) {
        companion object Key : CoroutineContext.Key<CoroutinePriority>

        override fun toString(): String = "CoroutinePriority($priority)"
    }

    internal class RunWithPriority(val runnable: Runnable, val priority: Int) : Runnable {

        override fun run() {
            runnable.run()
        }
    }

    internal class RunWithPriorityFuture(private val runWithPriority: RunWithPriority) :
        FutureTask<RunWithPriorityFuture>(runWithPriority.runnable, null), Comparable<RunWithPriorityFuture> {

        override fun compareTo(other: RunWithPriorityFuture): Int {
            return other.runWithPriority.priority - runWithPriority.priority
        }

    }

    fun submitAction(priority: Int, runnable: suspend () -> Unit): Job {
        return CoroutineScope(priorityDispatcher).launch(CoroutinePriority(priority)) {
            runnable.invoke()
        }
    }
}

is this the way @elizarov you would do it? The priorityqueue/threadexecutor under the hood is taken from java examples, I just want to be able to also run suspending functions when I call it