Critical section for coroutines

critical_section_for_coroutines.kt

import java.util.concurrent.ConcurrentHashMap
import kotlin.coroutines.Continuation
import kotlin.coroutines.resume
import kotlin.coroutines.suspendCoroutine

class KCriticalSection {
    private val suspendedJobs = ConcurrentHashMap<Int, Continuation<Boolean>>()
    private var id = AtomicInteger(1000)
    @Volatile private var isInsideCriticalSection = false

    suspend fun <T> synchronized(block: suspend () -> T): T {
        val thisJobId = id.getAndIncrement()
        while (isInsideCriticalSection) {
            suspendCoroutine { cont -> // <-- suspending call
                suspendedJobs[thisJobId] = cont
            }
            suspendedJobs.remove(thisJobId)
        }
        isInsideCriticalSection = true

        val result = block() // <-- suspending call

        isInsideCriticalSection = false
        suspendedJobs.forEach { (id, cont) ->
            cont.resume(true)
        }

        return result
    }
}

usage_of_ critical_section_for_coroutines.kt

val singleThread = Executors.newSingleThreadExecutor().asCoroutineDispatcher()

var accessToken = "" // a value to be fetched concurrently

// This method can be called from any thread or coroutine at any time
suspend fun concurrentMethod() {
    runBlocking(singleThread) { // <-- single thread will execute all coroutines
        KCriticalSection().synchronized {
            if (accessToken.isNotEmpty()) {
                return@synchronized // already done the job
            }

            accessToken = "fetch access token from network" // <-- might be a suspending call
        }
    }
}