Class/Object

monix.execution.misc

AsyncVar

Related Docs: object AsyncVar | package misc

Permalink

final class AsyncVar[A] extends AnyRef

Asynchronous mutable location, that is either empty or contains a value of type A.

It has 2 fundamental atomic operations:

put which fills the var if empty, or blocks (asynchronously) otherwise until the var is empty again
take which empties the var if full, returning the contained value, or blocks (asynchronously) otherwise until there is a value to pull

The AsyncVar is appropriate for building synchronization primitives and performing simple inter-thread communications. If it helps, it's similar with a BlockingQueue(capacity = 1), except that it doesn't block any threads, all waiting being callback-based.

Given its asynchronous, non-blocking nature, it can be used on top of Javascript as well.

Inspired by Control.Concurrent.MVar from Haskell.

Linear Supertypes

Ordering

Alphabetic
By Inheritance

Inherited

AsyncVar
AnyRef
Any

Hide All
Show All

Visibility

Public
All

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def put(a: A): Future[Unit]

Fills the AsyncVar if it is empty, or blocks (asynchronously) if the AsyncVar is full, until the given value is next in line to be consumed on take.
Fills the AsyncVar if it is empty, or blocks (asynchronously) if the AsyncVar is full, until the given value is next in line to be consumed on take.
This operation is atomic.
returns
a future that will complete when the put operation succeeds in filling the AsyncVar, with the given value being next in line to be consumed

See also
unsafePut for the raw, unsafe version that can work with plain callbacks.
def read: Future[A]

Tries reading the current value, or blocks (asynchronously) otherwise, until there is a value available, at which point the operation resorts to a take followed by a put.
Tries reading the current value, or blocks (asynchronously) otherwise, until there is a value available, at which point the operation resorts to a take followed by a put.
This read operation is equivalent to:
```
for (a <- v.take; _ <- v.put(a)) yield a
```
This operation is not atomic. Being equivalent with a take followed by a put, in order to ensure that no race conditions happen, additional synchronization is necessary. See AsyncSemaphore for a possible solution.
returns
a future that might already be completed in case the result is available immediately

See also
unsafeRead for the raw, unsafe version that can work with plain callbacks.
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def take: Future[A]

Empties the var if full, returning the contained value, or blocks (asynchronously) until a value is available.
Empties the var if full, returning the contained value, or blocks (asynchronously) until a value is available.
This operation is atomic.

See also
unsafeTake for the raw, unsafe version that can work with plain callbacks.
def toString(): String

Definition Classes
AnyRef → Any
def unsafePut(a: A, await: Listener[Unit]): Boolean

Fills the AsyncVar if it is empty, or blocks (asynchronously) if the AsyncVar is full, until the given value is next in line to be consumed on take (or unsafeTake).
Fills the AsyncVar if it is empty, or blocks (asynchronously) if the AsyncVar is full, until the given value is next in line to be consumed on take (or unsafeTake).
This operation is atomic.
a
is the value to store
await
is a callback that, only in case of asynchronous blocking, will get called when the blocking is over and the operation succeeded
returns
true if the operation succeeded already, with no blocking necessary, or false if the operation is blocked because the var is already full

Annotations
@tailrec()
See also
put for the safe future-enabled version.
def unsafeRead(await: Listener[A]): A

Tries reading the current value, or blocks (asynchronously) otherwise, until there is a value available, at which point the operation resorts to a take followed by a put.
Tries reading the current value, or blocks (asynchronously) otherwise, until there is a value available, at which point the operation resorts to a take followed by a put.
This read operation is equivalent to:
```
for (a <- v.take; _ <- v.put(a)) yield a
```
This operation is not atomic. Being equivalent with a take followed by a put, in order to ensure that no race conditions happen, additional synchronization is necessary. See AsyncSemaphore for a possible solution.
await
is a callback that, only in case of asynchronous blocking, will get called sometime in the future with a value
returns
a value of type A if the operation succeeded already, with no blocking necessary, or null if async blocking is in progress (in which case the await callback gets called with the result)

See also
read for the safe future-enabled version.
def unsafeTake(await: Listener[A]): A

Empties the var if full, returning the contained value, or blocks (asynchronously) until a value is available.
Empties the var if full, returning the contained value, or blocks (asynchronously) until a value is available.
This operation is atomic.
await
is a callback that, only in case of asynchronous blocking, will get called sometime in the future with a value
returns
a value of type A if the operation succeeded already, with no blocking necessary, or null if async blocking is in progress (in which case the await callback gets called with the result)

Annotations
@tailrec()
See also
take for the safe future-enabled version.
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )

Inherited from AnyRef

Inherited from Any

Ungrouped