import kotlinx.coroutines.*
import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock
import kotlin.coroutines.CoroutineContext
import kotlin.coroutines.EmptyCoroutineContext

fun main() = runBlocking {
    val lock = CloseableMutex()
    
    // from class A in scope A
    queuedLaunch(lock) {
        // create a command and poll on it ...
        println("hello")
        delay(2_000)
    }
    
    // from class B in scope B
    queuedLaunch(lock, terminateQueueAfterwards = true) {
        // create a command and poll on it ...
        println("hello 2")
        delay(1_000)
    }
    
    // from class C in scope C
    queuedLaunch(lock) {
        // create a command and poll on it ...
        println("hello 3")
        delay(3_000)
    }
}

fun CoroutineScope.queuedLaunch(
    mutex: CloseableMutex,
    context: CoroutineContext = EmptyCoroutineContext,
    terminateQueueAfterwards: Boolean = false,
    block: suspend CoroutineScope.() -> Unit,
) {
    launch(context) {
        // wait my turn
        mutex.withCancellableLock {
            // then execute
            block()
            if (terminateQueueAfterwards) {
                mutex.closed = true
            }
        }
    }
}

class CloseableMutex: Mutex by Mutex() {
    var closed = false

    suspend inline fun <T> withCancellableLock(owner: Any? = null, action: () -> T): T =
        withLock(owner) {
            if (closed) throw CancellationException()
            else action()
        }
}

hello
hello 2

queuedLaunch