class ThreadBox<out T>
A threadbox is a simple utility that makes it harder to forget to take a lock before accessing some shared state. Simply define a private class to hold the data that must be grouped under the same lock, and then pass the only instance to the ThreadBox constructor. You can now use the locked method with a lambda to take the lock in a way that ensures it'll be released if there's an exception.
Note that this technique is not infallible: if you capture a reference to the fields in another lambda which then gets stored and invoked later, there may still be unsafe multi-threaded access going on, so watch out for that. This is just a simple guard rail that makes it harder to slip up.
Example:
private class MutableState { var i = 5 }
private val state = ThreadBox(MutableState())
val ii = state.locked { i }
ThreadBox(content: T, lock: ReentrantLock = ReentrantLock())
A threadbox is a simple utility that makes it harder to forget to take a lock before accessing some shared state. Simply define a private class to hold the data that must be grouped under the same lock, and then pass the only instance to the ThreadBox constructor. You can now use the locked method with a lambda to take the lock in a way that ensures it'll be released if there's an exception. |
val content: T |
|
val lock: ReentrantLock |
fun <R> alreadyLocked(body: T.() -> R): R |
|
fun checkNotLocked(): Unit |
|
fun <R> locked(body: T.() -> R): R |
fun <T> Any.declaredField(name: String): DeclaredField<T>
Returns a DeclaredField wrapper around the declared (possibly non-public) instance field of the receiver object. fun <T> Any.declaredField(clazz: KClass<*>, name: String): DeclaredField<T>
Returns a DeclaredField wrapper around the (possibly non-public) instance field of the receiver object, but declared in its superclass clazz. |