103 lines
3.1 KiB
Kotlin
103 lines
3.1 KiB
Kotlin
package dev.inmo.micro_utils.coroutines
|
|
|
|
import kotlin.contracts.ExperimentalContracts
|
|
import kotlin.contracts.InvocationKind
|
|
import kotlin.contracts.contract
|
|
|
|
/**
|
|
* Composite mutex which works with next rules:
|
|
*
|
|
* * [acquireRead] require to [writeMutex] be free. Then it will take one lock from [readSemaphore]
|
|
* * [releaseRead] will just free up one permit in [readSemaphore]
|
|
* * [lockWrite] will lock [writeMutex] and then await while all [readSemaphore] will be freed
|
|
* * [unlockWrite] will just unlock [writeMutex]
|
|
*/
|
|
class SmartRWLocker(private val readPermits: Int = Int.MAX_VALUE, writeIsLocked: Boolean = false) {
|
|
private val _readSemaphore = SmartSemaphore.Mutable(permits = readPermits, acquiredPermits = 0)
|
|
private val _writeMutex = SmartMutex.Mutable(locked = writeIsLocked)
|
|
|
|
val readSemaphore: SmartSemaphore.Immutable = _readSemaphore.immutable()
|
|
val writeMutex: SmartMutex.Immutable = _writeMutex.immutable()
|
|
|
|
/**
|
|
* Do lock in [readSemaphore] inside of [writeMutex] locking
|
|
*/
|
|
suspend fun acquireRead() {
|
|
_writeMutex.withLock {
|
|
_readSemaphore.acquire()
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Release one read permit in [readSemaphore]
|
|
*/
|
|
suspend fun releaseRead(): Boolean {
|
|
return _readSemaphore.release()
|
|
}
|
|
|
|
/**
|
|
* Locking [writeMutex] and wait while all [readSemaphore] permits will be freed
|
|
*/
|
|
suspend fun lockWrite() {
|
|
_writeMutex.lock()
|
|
readSemaphore.waitRelease(readPermits)
|
|
}
|
|
|
|
/**
|
|
* Unlock [writeMutex]
|
|
*/
|
|
suspend fun unlockWrite(): Boolean {
|
|
return _writeMutex.unlock()
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Will call [SmartSemaphore.Mutable.lock], then execute [action] and return the result after [SmartSemaphore.Mutable.unlock]
|
|
*/
|
|
@OptIn(ExperimentalContracts::class)
|
|
suspend inline fun <T> SmartRWLocker.withReadAcquire(action: () -> T): T {
|
|
contract {
|
|
callsInPlace(action, InvocationKind.EXACTLY_ONCE)
|
|
}
|
|
|
|
acquireRead()
|
|
try {
|
|
return action()
|
|
} finally {
|
|
releaseRead()
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Will wait until the [SmartSemaphore.permitsStateFlow] of [this] instance will have [permits] count free permits.
|
|
*
|
|
* Anyway, after the end of this block there are no any guaranties that [SmartSemaphore.freePermits] >= [permits] due to
|
|
* the fact that some other parties may lock it again
|
|
*/
|
|
suspend fun SmartRWLocker.waitReadRelease(permits: Int = 1) = readSemaphore.waitRelease(permits)
|
|
|
|
/**
|
|
* Will call [SmartMutex.Mutable.lock], then execute [action] and return the result after [SmartMutex.Mutable.unlock]
|
|
*/
|
|
@OptIn(ExperimentalContracts::class)
|
|
suspend inline fun <T> SmartRWLocker.withWriteLock(action: () -> T): T {
|
|
contract {
|
|
callsInPlace(action, InvocationKind.EXACTLY_ONCE)
|
|
}
|
|
|
|
lockWrite()
|
|
try {
|
|
return action()
|
|
} finally {
|
|
unlockWrite()
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Will wait until the [SmartMutex.lockStateFlow] of [this] instance will be false.
|
|
*
|
|
* Anyway, after the end of this block there are no any guaranties that [SmartMutex.isLocked] == false due to the fact
|
|
* that some other parties may lock it again
|
|
*/
|
|
suspend fun SmartRWLocker.waitWriteUnlock() = writeMutex.waitUnlock()
|