get()

CoroutineScope.future{}

get()

get()

get()

CoroutineScope

future{}

supervisorScope

SupervisorJob()

SupervisorJob(coroutineScope.coroutineContext[Job])

class MyAsyncLoadingCache {
    private val scope = CoroutineScope(SupervisorJob() + someDispatcher)
    .... 
    suspend fun getData(key: Key) : Data {
        val data: Data = scope.async { ..... }.await()
        return data
    }
    ...

   fun destroy()  { scope.cancel() }
}

close

fun destroy

MyAsyncLoadingCache.scope

MyAsyncLoadingCache.destroy()

scope.async

CancelationException

scope.async { ....}.await()

No function should create coroutines that outlive the function call’s lifetime, unless explicitly provided with a CoroutineScope defining the created coroutine’s lifetime.

No function should create coroutines that outlive the function call’s lifetime, unless explicitly provided with a CoroutineScope defining the created coroutine’s lifetime, or the function is a method on an object with a

close()

-style method that will cancel all spawned coroutines.

class InMemAsyncCache<K : Any, V>(
    loader: suspend (K) -> V,
    dispatcher: CoroutineContext,
) {
    class Value<V>(val value: V)

    private val scope = CoroutineScope(SupervisorJob() + dispatcher)
    private val under = Caffeine.newBuilder().let { builder ->
        builder.buildAsync<K, Value<V>> { ... }
    }

    suspend fun get(key: K): V = scope.async { under.get(key) }.await().value

    fun destroy() { scope.cancel() }
}

.future

buildAsync

loader

suspend

nestedScope.future

dispatcher: CoroutineContext = EmptyCoroutineContext

scope.future { .... }

fun close()

cache1.close(); cache2.close(); cache3.close()

Closeable

fun CouroutineScope.doSomething(...)

interface ClosableCoroutineScope : CoroutineScope, AutoClosable {
    override fun close() = cancel()
    
    companion object {
        operator fun invoke(context: CoroutineContext) : ClosableCoroutineScope = 
            object: ClosableCoroutineScope {
                override val coroutineContext = context
            }
    }
}

class MyCache(context: CoroutineContext): ClosableCoroutineScope by ClosableCoroutineScope(context + SupervisorJob()) {
    ...
    fun getValue(key: Key): Data = async { ... }.await()
    ...
}

use