Solution: Suspended lazy
fun <T> suspendLazy(initializer: suspend () -> T): SuspendLazy<T>{
var innerInitializer: (suspend () -> T)? = initializer
val mutex = Mutex()
var holder: Any? = Any()
return object : SuspendLazy<T> {
override val isInitialized: Boolean
get() = innerInitializer == null
override fun valueOrNull(): T? =
if (isInitialized) holder as T else null
@Suppress("UNCHECKED_CAST")
override suspend fun invoke(): T =
if (isInitialized) holder as T
else mutex.withLock {
innerInitializer?.let {
holder = it()
innerInitializer = null
}
holder as T
}
}
}
Example solution in playground
import kotlinx.coroutines.*
import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock
import kotlinx.coroutines.test.advanceTimeBy
import kotlinx.coroutines.test.currentTime
import kotlinx.coroutines.test.runCurrent
import kotlinx.coroutines.test.runTest
import kotlin.coroutines.CoroutineContext
import org.junit.Test
import kotlin.test.assertEquals
import kotlin.test.assertTrue
fun <T> suspendLazy(initializer: suspend () -> T): SuspendLazy<T>{
var innerInitializer: (suspend () -> T)? = initializer
val mutex = Mutex()
var holder: Any? = Any()
return object : SuspendLazy<T> {
override val isInitialized: Boolean
get() = innerInitializer == null
override fun valueOrNull(): T? =
if (isInitialized) holder as T else null
@Suppress("UNCHECKED_CAST")
override suspend fun invoke(): T =
if (isInitialized) holder as T
else mutex.withLock {
innerInitializer?.let {
holder = it()
innerInitializer = null
}
holder as T
}
}
}
interface SuspendLazy<T> : suspend () -> T {
val isInitialized: Boolean
fun valueOrNull(): T?
override suspend operator fun invoke(): T
}
class SuspendLazyTest {
@Test
fun should_produce_value() = runTest {
val lazyValue = suspendLazy { delay(1000); 123 }
assertEquals(123, lazyValue())
assertEquals(1000, currentTime)
}
@Test
fun should_not_recalculate_value() = runTest {
var next = 1
val lazyValue = suspendLazy { delay(1000); next++ }
assertEquals(1, lazyValue())
assertEquals(1, lazyValue())
assertEquals(1, lazyValue())
assertEquals(1, lazyValue())
assertEquals(1000, currentTime)
}
@Test
fun should_not_calculate_value_multiple_times_when_multiple_coroutines_access_it() = runBlocking {
var calculatedTimes = 0
val lazyValue = suspendLazy { delay(1000); calculatedTimes++ }
coroutineScope {
repeat(10_000) {
launch {
lazyValue()
}
}
}
assertEquals(1, calculatedTimes)
}
@Test
fun should_try_again_when_failure_during_value_initialization() = runTest {
var next = 0
val lazyValue = suspendLazy {
val v = next++
if (v < 2) throw Error()
v
}
assertTrue(runCatching { lazyValue() }.isFailure)
assertTrue(runCatching { lazyValue() }.isFailure)
assertEquals(2, lazyValue())
assertEquals(2, lazyValue())
assertEquals(2, lazyValue())
}
@Test
fun should_use_context_of_the_first_caller() = runTest {
var ctx: CoroutineContext? = null
val lazyValue = suspendLazy {
ctx = currentCoroutineContext()
123
}
val name1 = CoroutineName("ABC")
withContext(name1) {
lazyValue()
}
assertEquals(name1, ctx?.get(CoroutineName))
val name2 = CoroutineName("DEF")
withContext(name2) {
lazyValue()
}
assertEquals(name1, ctx?.get(CoroutineName))
}
@Test
fun should_set_is_initialized() = runTest {
val lazyValue = suspendLazy { delay(1000); 123 }
assertEquals(false, lazyValue.isInitialized)
launch { lazyValue() }
assertEquals(false, lazyValue.isInitialized)
advanceTimeBy(1000)
assertEquals(false, lazyValue.isInitialized)
runCurrent()
assertEquals(true, lazyValue.isInitialized)
}
}
