Abstract Offer
class for Java compatibility.
Abstract Spool
class for Java compatibility.
An AsyncMutex is a traditional mutex but with asynchronous execution.
An asynchronous FIFO queue.
An AsyncSemaphore is a traditional semaphore but with asynchronous execution.
An AsyncSemaphore is a traditional semaphore but with asynchronous execution.
Grabbing a permit returns a Future[Permit]
.
Basic usage:
val semaphore = new AsyncSemaphore(n) ... semaphore.acquireAndRun() { somethingThatReturnsFutureT() }
Calls to acquire() and acquireAndRun are serialized, and tickets are given out fairly (in order of arrival).
AsyncMutex for a mutex version.
A scheduler that bridges tasks submitted by external threads into local executor threads.
A scheduler that bridges tasks submitted by external threads into local executor threads. All tasks submitted locally are executed on local threads.
Note: This scheduler expects to create executors with unbounded capacity.
Thus it does not expect and has undefined behavior for any
RejectedExecutionException
s other than those encountered after executor
shutdown.
An unbuffered FIFO queue, brokered by Offer
s.
An unbuffered FIFO queue, brokered by Offer
s. Note that the queue is
ordered by successful operations, not initiations, so one
and two
may not be received in that order with this code:
val b: Broker[Int] b ! 1 b ! 2
But rather we need to explicitly sequence them:
val b: Broker[Int] for { () <- b ! 1 () <- b ! 2 } ()
BUGS: the implementation would be much simpler in the absence of cancellation.
A named Scheduler mix-in that causes submitted tasks to be dispatched according to an java.util.concurrent.ExecutorService created by an abstract factory function.
An efficient thread-local, direct-dispatch scheduler.
A java.util.concurrent.ThreadFactory which creates threads with a name indicating the pool from which they originated.
A java.util.concurrent.ThreadFactory which creates threads with a name indicating the pool from which they originated.
A new java.lang.ThreadGroup (named name
) is created as a sub-group of
whichever group to which the thread that created the factory belongs. Each
thread created by this factory will be a member of this group and have a
unique name including the group name and an monotonically increasing number.
The intention of this naming is to ease thread identification in debugging
output.
For example, a NamedPoolThreadFactory
with name="writer"
will create a
ThreadGroup
named "writer" and new threads will be named "writer-1",
"writer-2", etc.
An offer to communicate with another process.
An offer to communicate with another process. The offer is
parameterized on the type of the value communicated. An offer that
sends a value typically has type {{Unit}}. An offer is activated by
synchronizing it, which is done with sync()
.
Note that Offers are persistent values -- they may be synchronized multiple times. They represent a standing offer of communication, not a one-shot event.
Synchronization is performed via a two-phase commit process.
prepare()
commences the transaction, and when the other party is
ready, it returns with a transaction object, Tx[T]
. This must then
be ackd or nackd. If both parties acknowledge, Tx.ack()
returns
with a commit object, containing the value. This finalizes the
transaction. Please see the Tx
documentation for more details on
that phase of the protocol.
Note that a user should never perform this protocol themselves --
synchronization should always be done with sync()
.
Future interrupts are propagated, and failure is passed through. It is up to the implementer of the Offer to decide on failure semantics, but they are always passed through in all of the combinators.
Note: There is a Java-friendly API for this trait: com.twitter.concurrent.AbstractOffer.
An interface for scheduling java.lang.Runnable tasks.
Efficient ordered serialization of operations.
Efficient ordered serialization of operations.
Note: This should not be used in place of Scala's
synchronized
, but rather only when serialization semantics are
required.
A spool is an asynchronous stream.
A spool is an asynchronous stream. It more or less mimics the scala {{Stream}} collection, but with cons cells that have either eager or deferred tails.
Construction of eager Spools is done with either Spool.cons or the {{**::}} operator. To construct a lazy/deferred Spool which materializes its tail on demand, use the {{*::}} operator. In order to use these operators for deconstruction, they must be imported explicitly (ie: {{import Spool.{*::, **:: }}} )
def fill(rest: Promise[Spool[Int]]) { asyncProcess foreach { result => if (result.last) { rest() = Return(result **:: Spool.empty) } else { val next = new Promise[Spool[Int]] rest() = Return(result *:: next) fill(next) } } } val rest = new Promise[Spool[Int]] fill(rest) firstElem *:: rest
Note: There is a Java-friendly API for this trait: com.twitter.concurrent.AbstractSpool.
explicitly (ie: {{import Spool.{*::, **:: }}}
def fill(rest: Promise[Spool[Int]]) { asyncProcess foreach { result => if (result.last) { rest() = Return(result **:: Spool.empty) } else { val next = new Promise[Spool[Int]] rest() = Return(result *:: next) fill(next) } } } val rest = new Promise[Spool[Int]] fill(rest) firstElem *:: rest
Note: There is a Java-friendly API for this trait: com.twitter.concurrent.AbstractSpool.
A SpoolSource is a simple object for creating and populating a Spool-chain.
A SpoolSource is a simple object for creating and populating a Spool-chain. apply() returns a Future[Spool] that is populated by calls to offer(). This class is thread-safe.
A scheduler that dispatches directly to an underlying Java cached threadpool executor.
A Tx
is used to mediate multi-party transactions with the following
protocol:
A Tx
is used to mediate multi-party transactions with the following
protocol:
(Since version 6.2.x) use guava's Multimaps.synchronizedMultimap
The ConcurrentPool provides a concurrent object pool on top of the java.util.concurrent primitives.
The ConcurrentPool provides a concurrent object pool on top of the java.util.concurrent primitives.
The pool currently supports only FIFO ordering of items, and does not yet clean up per-key object lists.
(Since version 6.2.x) use finagle's BufferingPool
Note: There is a Java-friendly API for this object: com.twitter.concurrent.Offers.
A global scheduler.
Note: There is a Java-friendly API for this object: com.twitter.concurrent.Spools.
Note: There is a Java-friendly API for this object: com.twitter.concurrent.Txs.
An AsyncMutex is a traditional mutex but with asynchronous execution.
Basic usage:
AsyncSemaphore for a semaphore version.