How would I implement an "offensive" `Mutex`, aka a `Mutex` where the coroutine holding the lock is ...

# coroutines

[reactormonk]

How would I implement an "offensive" Mutex, aka a Mutex where the coroutine holding the lock is killed instead of waited for?

[Chris Lee]

Killed… when? It holds the lock and is presumably doing the work, just exit/cancel the coroutine?

[Alex Vanyo]

You might be interested in MutatorMutex that’s implemented in Compose:

https://cs.android.com/androidx/platform/frameworks/support/+/androidx-main:compose/[…]torMutex.kt;l=78;drc=64c19e2612ecaca5c53a3f7b96d7b4fec2991709

[Daniel Pitts]

I've very interested in what possible use-case you would have.

[PHondogo]

If i correctly understand (jvm code example cause of atomic reference):

class OffensiveMutex {

    private val currentJob = AtomicReference<Job?>()

    suspend fun <T> withLock(lambda: suspend () -> T): T {
        return coroutineScope {
            val job = currentCoroutineContext().job
            val prevJob = currentJob.getAndSet(job)
            try {
              prevJob?.cancelAndJoin()
                lambda()
            } finally {
                currentJob.compareAndSet(job, null)
            }
        }
    }
}

suspend fun main() {
    coroutineScope {
        val mutex = OffensiveMutex()
        repeat(10) {
            launch {
                mutex.withLock {
                    try {
                        delay(100)
                        println("finish $it")
                    } catch (e: CancellationException) {
                        println("cancel $it")
                        throw e
                    }
                }
            }
            delay(1)
        }
        mutex.withLock {
            println("finish final")
        }
    }
}