const classafConcurrent::Synchronized

sys::Obj
  afConcurrent::Synchronized

Provides synchronized access to blocks of code. Example usage:

 
lock := Synchronized(ActorPool())

val := lock.synchronized |->Obj?| {
    // ...
    // important stuff
    // ...
    return 69
}

IoC Injection

The Concurrent library defines an IoC SynchronizedProvider that injects Synchronized instances directly into your class. To use, ensure the id field is set to a contributed ActorPool:

const class Example {

    @Inject { id="actorPoolId" } 
    const Synchronized lock

    new make(|This|in) { in(this) }
}

async

Source

virtual Future async(|->Obj? f)

Runs the given func asynchronously.

Errs that occur within the block are logged but not re-thrown unless you call get() on the returned Future.

The given func and return value must be immutable.

asyncLater

Source

virtual Future asyncLater(Duration d, |->Obj? f)

Runs the given func asynchronously, after the given duration has elapsed.

Errs that occur within the block are logged but not rethrown unless you call get() on the returned Future.

The given func and return value must be immutable.

inSync

Source

Bool inSync()

Returns true if the current thread is running inside the synchronised Actor. E.g.:

lock := Synchronized(ActorPool())
lock.inSync    // --> false

lock.synchronized |->| {
  lock.inSync  // --> true
  ...
}

make

Source

new make(ActorPool actorPool, Duration? timeout := null, |This? f := null)

Create a Synchronized class from the given ActorPool and timeout.

The default timeout of null blocks forever.

reentrant

Source

const Bool reentrant := true

Determines if this synchronised lock is re-entrant or not. Re-entrant locks allow multiple nested calls to synchronized() (on this object) without fear of deadlocks.

Because re-entrant locks are often considered an indication of bad design, setting reentrant to false will disable nested calls to synchronized(), throwing an Err instead.

Defaults to true.

sync

Source

Obj? sync(|->Obj? f)

Alias for synchronized().

Effectively wraps the given func in a Java synchronized { ... } block and returns its calculated value.

The given func and return value must be immutable.

synchronized

Source

virtual Obj? synchronized(|->Obj? f)

This effectively wraps the given func in a Java synchronized { ... } block and returns its calculated value.

The given func and return value must be immutable.

timeout

Source

const Duration? timeout

The default timeout to use when waiting for synchronized blocks to complete.

The default timeout of null blocks forever.