AsyncSemaphore

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
def acquire(): CancelableFuture[Unit]

Acquires a single permit.
Acquires a single permit. Alias for acquireN(1).

Annotations
@UnsafeBecauseImpure()
See also
acquireN for a version that can acquire multiple permits
withPermit, the preferred way to acquire and release
def acquireN(n: Long): CancelableFuture[Unit]

Acquires n permits.
Acquires n permits.
The returned effect semantically blocks until all requested permits are available. Note that acquires are satisfied in strict FIFO order, so given an AsyncSemaphore with 2 permits available, an acquireN(3) will always be satisfied before a later call to acquireN(1).
n
number of permits to acquire - must be >= 0
returns
a future that will complete when the acquisition has succeeded or that can be cancelled, removing the listener from the queue (to prevent memory leaks in race conditions)

Annotations
@UnsafeBecauseImpure()
See also
acquire for a version acquires a single permit
withPermit, the preferred way to acquire and release
final def asInstanceOf[T0]: T0

Definition Classes
Any
def available(): Long

Returns the number of permits currently available.
Returns the number of permits currently available. Always non-negative.
The protocol is unsafe, the semaphore is used in concurrent settings and thus the value returned isn't stable or reliable. Use with care.

Annotations
@UnsafeProtocol() @UnsafeBecauseImpure()
def awaitAvailable(n: Long): CancelableFuture[Unit]

Returns a future that will be complete when the specified number of permits are available.
Returns a future that will be complete when the specified number of permits are available.
The protocol is unsafe because by the time the returned future completes, some other process might have already acquired the available permits and thus usage of awaitAvailable can lead to fragile concurrent logic. Use with care.
Can be useful for termination logic, for example to execute a piece of logic once all available permits have been released.
n
is the number of permits waited on

Annotations
@UnsafeProtocol() @UnsafeBecauseImpure()
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def count(): Long

Obtains a snapshot of the current count.
Obtains a snapshot of the current count. Can be negative.
Like available when permits are available but returns the number of permits callers are waiting for when there are no permits available.

Annotations
@UnsafeProtocol() @UnsafeBecauseImpure()
def emptyCancelable: Cancelable

Attributes
protected
Definition Classes
AsyncSemaphore → GenericSemaphore
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
def makeCancelable(f: (Listener[Unit]) ⇒ Unit, p: Listener[Unit]): Cancelable

Attributes
protected
Definition Classes
AsyncSemaphore → GenericSemaphore
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def release(): Unit

Releases a permit, returning it to the pool.
Releases a permit, returning it to the pool.
If there are consumers waiting on permits being available, then the first in the queue will be selected and given a permit immediately.

Annotations
@UnsafeBecauseImpure()
See also
withPermit, the preferred way to acquire and release
def releaseN(n: Long): Unit

Releases n permits, potentially unblocking up to n outstanding acquires.
Releases n permits, potentially unblocking up to n outstanding acquires.
n
number of permits to release - must be >= 0

Annotations
@UnsafeBecauseImpure()
See also
withPermit, the preferred way to acquire and release
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
def tryAcquire(): Boolean

Alias for tryAcquireN(1).
Alias for tryAcquireN(1).
The protocol is unsafe, because with the "try*" methods the user needs a firm grasp of what race conditions are and how they manifest and usage of such methods can lead to very fragile logic.

Annotations
@UnsafeProtocol() @UnsafeBecauseImpure()
See also
withPermit the preferred way to acquire and release
acquire for the version that can wait for acquisition
tryAcquireN for the version that can acquire multiple permits
def tryAcquireN(n: Long): Boolean

Acquires n permits now and returns true, or returns false immediately.
Acquires n permits now and returns true, or returns false immediately. Error if n < 0.
The protocol is unsafe, because with the "try*" methods the user needs a firm grasp of what race conditions are and how they manifest and usage of such methods can lead to very fragile logic.
n
number of permits to acquire - must be >= 0

Annotations
@UnsafeProtocol() @UnsafeBecauseImpure()
See also
withPermit, the preferred way to acquire and release
acquireN for the version that can wait for acquisition
tryAcquire for the alias that acquires a single permit
final def unsafeAcquireN(n: Long, await: Listener[Unit]): Cancelable

Attributes
protected
Definition Classes
GenericSemaphore
Annotations
@tailrec()
final def unsafeAsyncAcquireN(n: Long, await: Listener[Unit]): Cancelable

Attributes
protected
Definition Classes
GenericSemaphore
Annotations
@tailrec()
final def unsafeAvailable(): Long

Attributes
protected
Definition Classes
GenericSemaphore
final def unsafeAwaitAvailable(n: Long, await: Listener[Unit]): Cancelable

Attributes
protected
Definition Classes
GenericSemaphore
Annotations
@tailrec()
final def unsafeCount(): Long

Attributes
protected
Definition Classes
GenericSemaphore
final def unsafeReleaseN(n: Long): Unit

Attributes
protected
Definition Classes
GenericSemaphore
Annotations
@tailrec()
final def unsafeTryAcquireN(n: Long): Boolean

Attributes
protected
Definition Classes
GenericSemaphore
Annotations
@tailrec()
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( ... )
def withPermit[A](f: () ⇒ Future[A]): CancelableFuture[A]

Returns a new future, ensuring that the given source acquires an available permit from the semaphore before it is executed.
Returns a new future, ensuring that the given source acquires an available permit from the semaphore before it is executed.
The returned future also takes care of resource handling, releasing its permit after being complete.
f
is a function returning the Future instance we want to evaluate after we get the permit from the semaphore

Annotations
@UnsafeBecauseImpure()
def withPermitN[A](n: Long)(f: () ⇒ Future[A]): CancelableFuture[A]

Returns a new future, ensuring that the given source acquires n available permits from the semaphore before it is executed.
Returns a new future, ensuring that the given source acquires n available permits from the semaphore before it is executed.
The returned future also takes care of resource handling, releasing its permits after being complete.
n
is the number of permits required for the given function to be executed
f
is a function returning the Future instance we want to evaluate after we get the permit from the semaphore

Annotations
@UnsafeBecauseImpure()

Related Docs: object AsyncSemaphore | package execution

final class AsyncSemaphore extends GenericSemaphore[Cancelable]

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def acquire(): CancelableFuture[Unit]

def acquireN(n: Long): CancelableFuture[Unit]

final def asInstanceOf[T0]: T0

def available(): Long

def awaitAvailable(n: Long): CancelableFuture[Unit]

def clone(): AnyRef

def count(): Long

def emptyCancelable: Cancelable

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def makeCancelable(f: (Listener[Unit]) ⇒ Unit, p: Listener[Unit]): Cancelable

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def release(): Unit

def releaseN(n: Long): Unit

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

def tryAcquire(): Boolean

def tryAcquireN(n: Long): Boolean

final def unsafeAcquireN(n: Long, await: Listener[Unit]): Cancelable

final def unsafeAsyncAcquireN(n: Long, await: Listener[Unit]): Cancelable

final def unsafeAvailable(): Long

final def unsafeAwaitAvailable(n: Long, await: Listener[Unit]): Cancelable

final def unsafeCount(): Long

final def unsafeReleaseN(n: Long): Unit

final def unsafeTryAcquireN(n: Long): Boolean

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def withPermit[A](f: () ⇒ Future[A]): CancelableFuture[A]

def withPermitN[A](n: Long)(f: () ⇒ Future[A]): CancelableFuture[A]

Inherited from GenericSemaphore[Cancelable]

Inherited from Serializable

Inherited from Serializable

Inherited from AnyRef

Inherited from Any

Ungrouped