Do coroutines have some kind of a scheduler API? (Other than launching a new coroutine with

delay()

)

What are you trying to achieve?

I have some objects with time expiry, I want to execute an action whenever one of them expires

Cancellation? Nvm

I wrote a simple private lib which is based on this one https://pl.kotl.in/W3yf9Y7_Z

If you're just trying to schedule some code to run at some time in the future, launching a coroutine and calling

delay

is probably the most idiomatic way to do it with coroutines. That said, if you're on Android, WorkManager might be more appropriate depending on what kind of objects you're managing (are they only in memory or are they stored in a db?) and how far in the future you're scheduling.

I always wondered what is the best way to schedule millions of tasks, for small tasks I will just do delay and not worry about it but I have millions of pings I have to send on 15 second intervals and right now I have 1 thread that continuously runs in a loop looking at time stamps with a delay between iterations. But not sure if this is the best way and the difference between doing that, delay or using java scheduler. If anyone knows let me know

The overhead for

launch { delay(time); doSomething() }

is on the order of a few hundred bytes. Do it like this if that is Ok for you. Of course, a specialized solution would be more lighter-weight, but you’ll have to write it yourself if you want it to be optimized for your particular case.

@elizarov the problem with launch {delay()} is not the hundred bytes more the management of all those tasks, If you have millions won't it cause contention, perhaps performance problems, because when you delay you must be put back on the same thread, if that thread is busy then it can't and you will not be accurate on the delay. Underneath on the JVM I am assuming it is just an eventloop as well checking timestamps.

It should scale to millions without problems. You can test on your specific workloads to double check.

One big advantage of coroutines as a scheduler is the structured concurrency model. Think about nested scheduled tasks.

You'd have that problem with any scheduling system - the machine can only run as many tasks at once as it has cores. And if you're using the default dispatcher, your tasks will be scheduled onto a thread pool which will scale with available cores.

Slightly similar question - what about repeating tasks that should occur at a certain time? Obviously there are normal JVM solutions to this, like using a

ScheduledExecutorService

, just curious about kotlin solutions

Simple high level solution:

suspend fun scheduledPeriodicTask(
    time: Long,
    period: Long,
    context: CoroutineContext = EmptyCoroutineContext,
    task: suspend CoroutineScope.() -> Unit
): Unit =
    withContext(context) {
        delay(time)
        while (true) {
            task()
            delay(period)
        }
    }

Slightly off topic, but doesn't that method not inherit CoroutineScope from the outer function? I thought functions like that were supposed to be written as:

fun CoroutineScope.schedule()

so that the scope could be kept