Package org.apache.cassandra.utils.concurrent

Class SyncFuture<V>

  • Type Parameters:
    V -
    All Implemented Interfaces:
    com.google.common.util.concurrent.ListenableFuture<V>, io.netty.util.concurrent.Future<V>, java.util.concurrent.Future<V>, Awaitable, Future<V>
    Direct Known Subclasses:
    SyncFutureTask, SyncPromise
    public class SyncFuture<V>
extends AbstractFuture<V>
    Netty's DefaultPromise uses a mutex to coordinate notifiers AND waiters between the eventLoop and the other threads. Since we register cross-thread listeners, this has the potential to block internode messaging for an unknown number of threads for an unknown period of time, if we are unlucky with the scheduler (which will certainly happen, just with some unknown but low periodicity) At the same time, we manage some other efficiencies: - We save some space when registering listeners, especially if there is only one listener, as we perform no extra allocations in this case. - We permit efficient initial state declaration, avoiding unnecessary CAS or lock acquisitions when mutating a Promise we are ourselves constructing (and can easily add more; only those we use have been added) We can also make some guarantees about our behaviour here, although we primarily mirror Netty. Specifically, we can guarantee that notifiers are always invoked in the order they are added (which may be true for netty, but was unclear and is not declared). This is useful for ensuring the correctness of some of our behaviours in OutboundConnection without having to jump through extra hoops. The implementation loosely follows that of Netty's DefaultPromise, with some slight changes; notably that we have no synchronisation on our listeners, instead using a CoW list that is cleared each time we notify listeners. We handle special values slightly differently. We do not use a special value for null, instead using a special value to indicate the result has not been set yet. This means that once isSuccess() holds, the result must be a correctly typed object (modulo generics pitfalls). All special values are also instances of FailureHolder, which simplifies a number of the logical conditions.

    • Constructor Detail

      • SyncFuture

        protected SyncFuture()

      • SyncFuture

        protected SyncFuture​(V immediateSuccess)

      • SyncFuture

        protected SyncFuture​(java.lang.Throwable immediateFailure)

      • SyncFuture

        protected SyncFuture​(org.apache.cassandra.utils.concurrent.AbstractFuture.FailureHolder initialState)

      • SyncFuture

        protected SyncFuture​(io.netty.util.concurrent.GenericFutureListener<? extends io.netty.util.concurrent.Future<? super V>> listener)

      • SyncFuture

        protected SyncFuture​(org.apache.cassandra.utils.concurrent.AbstractFuture.FailureHolder initialState,
                     io.netty.util.concurrent.GenericFutureListener<? extends io.netty.util.concurrent.Future<? super V>> listener)

    • Method Detail

      • map

        public <T> Future<T> map​(java.util.function.Function<? super V,​? extends T> mapper,
                         java.util.concurrent.Executor executor)
        Support Futures.transform(com.google.common.util.concurrent.ListenableFuture<I>, com.google.common.base.Function<? super I, ? extends O>, java.util.concurrent.Executor) natively See AbstractFuture.addListener(GenericFutureListener) for ordering semantics.

      • flatMap

        public <T> Future<T> flatMap​(java.util.function.Function<? super V,​? extends Future<T>> flatMapper,
                             @Nullable
                             java.util.concurrent.Executor executor)
        Support Futures.transformAsync(ListenableFuture, AsyncFunction, Executor) natively See AbstractFuture.addListener(GenericFutureListener) for ordering semantics.

      • awaitUntil

        public boolean awaitUntil​(long deadline)
                   throws java.lang.InterruptedException
        Description copied from interface: Awaitable
        Await until the deadline (in nanoTime), throwing any interrupt. No spurious wakeups.
        Returns:
        true if we were signalled, false if the deadline elapsed
        Throws:
        java.lang.InterruptedException - if interrupted

      • await

        public Future<V> await()
                throws java.lang.InterruptedException
        Description copied from interface: Future
        Wait indefinitely for this future to complete, throwing any interrupt
        Throws:
        java.lang.InterruptedException - if interrupted