Package org.infinispan.util.concurrent

Class BlockingManagerImpl

java.lang.Object
org.infinispan.util.concurrent.BlockingManagerImpl
All Implemented Interfaces:
BlockingManager
public class BlockingManagerImpl extends Object implements BlockingManager

  • Constructor Details

    • BlockingManagerImpl

      public BlockingManagerImpl()

  • Method Details

    • runBlocking

      public CompletionStage<Void> runBlocking(Runnable runnable, Object traceId)
      Description copied from interface: BlockingManager
      Replacement for CompletionStage.runAsync() that invokes the Runnable in a blocking thread if the current thread is non-blocking or in the current thread if the current thread is blocking. The returned stage, if not complete, resumes any chained stage on the non-blocking executor.

      Note that if the current thread is blocking, the task is invoked in the current thread, meaning the stage is always completed when returned, so any chained stage is also invoked on the current thread.

      Specified by:
      runBlocking in interface BlockingManager
      Parameters:
      runnable - blocking operation that runs some code.
      traceId - an identifier that can be used to tell in a trace when an operation moves between threads.
      Returns:
      a stage that is completed after the runnable is done or throws an exception.

    • subscribeBlockingConsumer

      public <E> CompletionStage<Void> subscribeBlockingConsumer(org.reactivestreams.Publisher<E> publisher, Consumer<E> consumer, Object traceId)
      Description copied from interface: BlockingManager
      Subscribes to the provided publisher on the invoking thread. Published values are observed on a blocking thread one a time passed to the provided consumer. The returned stage if not complete will resume any chained stage on the non blocking executor.

      If no values are published the returned stage will be completed upon return of this method and require no thread context switches

      Note that if the current thread is blocking everything including subscription, publication and consumption of values will be done on the current thread.

      Specified by:
      subscribeBlockingConsumer in interface BlockingManager
      Type Parameters:
      E - the type of entries
      Parameters:
      publisher - publisher of values to consume
      consumer - consumer to handle the values
      traceId - an identifier that can be used to tell in a trace when an operation moves between threads
      Returns:
      a stage that is completed after all values are consumed

    • subscribeBlockingCollector

      public <T, A, R> CompletionStage<R> subscribeBlockingCollector(org.reactivestreams.Publisher<T> publisher, Collector<? super T,A,R> collector, Object traceId)
      Description copied from interface: BlockingManager
      Subscribes to the provided publisher on the invoking thread. Published values are observed on a blocking thread one a time passed to the provided collector. The returned stage if not complete will resume any chained stage on the non blocking executor.

      If no values are published the returned stage will be completed upon return of this method and require no thread context switches

      Note that if the current thread is blocking everything including subscription, publication and collection of values will be done on the current thread.

      Specified by:
      subscribeBlockingCollector in interface BlockingManager
      Type Parameters:
      T - the type of entries
      A - accumulator type of the entries
      R - final value type
      Parameters:
      publisher - publisher of values to collect
      collector - collector of the values
      traceId - an identifier that can be used to tell in a trace when an operation moves between threads
      Returns:
      a stage that when complete contains the collected values as a single value

    • supplyBlocking

      public <V> CompletionStage<V> supplyBlocking(Supplier<V> supplier, Object traceId)
      Description copied from interface: BlockingManager
      Replacement for CompletionStage.supplyAsync() that invokes the Supplier in a blocking thread (if the current thread is non-blocking) or in the current thread (if the current thread is blocking). The returned stage, if not complete, resumes any chained stage on the non-blocking executor.

      Note that if the current thread is blocking, the task is invoked in the current thread meaning the stage is always completed when returned, so any chained stage is also invoked on the current thread.

      Specified by:
      supplyBlocking in interface BlockingManager
      Type Parameters:
      V - the supplied type.
      Parameters:
      supplier - blocking operation that returns a value.
      traceId - an identifier that can be used to tell in a trace when an operation moves between threads.
      Returns:
      a stage that, when complete, contains the value returned from the supplier or a throwable.

    • handleBlocking

      public <I, O> CompletionStage<O> handleBlocking(CompletionStage<? extends I> stage, BiFunction<? super I,Throwable,? extends O> function, Object traceId)
      Description copied from interface: BlockingManager
      Replacement for CompletionStage.handleAsync() that invokes the BiFunction in a blocking thread (if the current thread is non-blocking) or in the current thread (if the current thread is blocking and the stage is completed). The returned stage, if not complete, resumes any chained stage on the non-blocking executor.

      Note that if the current thread is blocking and the stage is completed, the task is invoked in the current thread meaning the stage is always completed when returned, so any chained stage is also invoked on the current thread.

      Specified by:
      handleBlocking in interface BlockingManager
      Type Parameters:
      I - input value type to the function.
      O - output value type after being transformed via function.
      Parameters:
      stage - stage, that may or may not be complete, to handle.
      function - the blocking function.
      traceId - an identifier that can be used to tell in a trace when an operation moves between threads.
      Returns:
      a stage that, when complete, contains the value returned from the function or a throwable.

    • thenApplyBlocking

      public <I, O> CompletionStage<O> thenApplyBlocking(CompletionStage<? extends I> stage, Function<? super I,? extends O> function, Object traceId)
      Description copied from interface: BlockingManager
      Replacement for CompletionStage.thenApplyAsync() that invokes the Function in a blocking thread (if the current thread is non-blocking) or in the current thread (if the current thread is blocking and the stage is completed). The returned stage, if not complete, resumes any chained stage on the non-blocking executor.

      Note that if the current thread is blocking and the stage is completed, the task is invoked in the current thread meaning the stage is always completed when returned, so any chained stage is also invoked on the current thread.

      Specified by:
      thenApplyBlocking in interface BlockingManager
      Type Parameters:
      I - input value type to the function.
      O - output value type after being transformed via function.
      Parameters:
      stage - stage, that may or may not be complete, to apply.
      function - the blocking function.
      traceId - an identifier that can be used to tell in a trace when an operation moves between threads.
      Returns:
      a stage that, when complete, contains the value returned from the function or a throwable.

    • thenRunBlocking

      public <I> CompletionStage<Void> thenRunBlocking(CompletionStage<? extends I> stage, Runnable runnable, Object traceId)
      Description copied from interface: BlockingManager
      Replacement for CompletionStage.thenRunAsync(Runnable) that invokes the Runnable in a blocking thread (if the current thread is non-blocking) or in the current thread (if the current thread is blocking and the stage is completed). The returned stage, if not complete, resumes any chained stage on the non-blocking executor.

      Note that if the current thread is blocking and the stage is completed, the task is invoked in the current thread meaning the stage is always completed when returned, so any chained stage is also invoked on the current thread.

      Specified by:
      thenRunBlocking in interface BlockingManager
      Type Parameters:
      I - input value type to the function.
      Parameters:
      stage - stage, that may or may not be complete, to apply.
      runnable - blocking operation that runs some code.
      traceId - an identifier that can be used to tell in a trace when an operation moves between threads.
      Returns:
      a stage that is completed after the action is done or throws an exception.

    • thenComposeBlocking

      public <I, O> CompletionStage<O> thenComposeBlocking(CompletionStage<? extends I> stage, Function<? super I,? extends CompletionStage<O>> function, Object traceId)
      Description copied from interface: BlockingManager
      Replacement for CompletionStage.thenComposeAsync() that invokes the Function in a blocking thread (if the current thread is non-blocking) or in the current thread (if the current thread is blocking and the stage is completed). The returned stage, if not complete, resumes any chained stage on the non-blocking executor.

      Note that if the current thread is blocking and the stage is completed, the task is invoked in the current thread meaning the stage is always completed when returned, so any chained stage is also invoked on the current thread.

      Note this method is not normally required as the Function already returns a CompletionStage and it is recommended to have the composed function just be non-blocking to begin with. This method is here when invoking some method that may spuriously block to be safe.

      Specified by:
      thenComposeBlocking in interface BlockingManager
      Type Parameters:
      I - input value type to the function.
      O - output value type after being transformed via function.
      Parameters:
      stage - stage, that may or may not be complete, to compose.
      function - the blocking function.
      traceId - an identifier that can be used to tell in a trace when an operation moves between threads.
      Returns:
      a stage that, when complete, contains the value returned from the composed function or a throwable.

    • whenCompleteBlocking

      public <V> CompletionStage<V> whenCompleteBlocking(CompletionStage<V> stage, BiConsumer<? super V,? super Throwable> biConsumer, Object traceId)
      Description copied from interface: BlockingManager
      Replacement for CompletionStage.whenCompleteAsync() that invokes the BiConsumer in a blocking thread (if the current thread is non-blocking) or in the current thread (if the current thread is blocking). The returned stage, if not complete, resumes any chained stage on the non-blocking executor.

      Note that if the current thread is blocking and the stage is completed, the task is invoked in the current thread meaning the stage is always completed when returned, so any chained stage is also invoked on the current thread.

      Specified by:
      whenCompleteBlocking in interface BlockingManager
      Type Parameters:
      V - stage value type.
      Parameters:
      stage - stage, that may or may not be complete, to apply.
      biConsumer - the blocking biConsumer.
      traceId - an identifier that can be used to tell in a trace when an operation moves between threads.
      Returns:
      a stage that is complete when the biConsumer is complete, but retains the results from the original stage.

    • continueOnNonBlockingThread

      public <V> CompletionStage<V> continueOnNonBlockingThread(CompletionStage<V> delay, Object traceId)
      Description copied from interface: BlockingManager
      When the provided stage is complete, continue the completion chain of the returned CompletionStage on the supplied executor. If tracing is enabled, a trace message is printed using the object as an identifier to more easily track the transition between threads.

      This method is useful when an asynchronous computation completes and you do not want to run further processing on the thread that returned it. An example may be that some blocking operation is performed on a special blocking thread pool. However when the blocking operation completes we want to continue processing that result in a thread pool that is for computational tasks.

      If the supplied stage is already completed when invoking this command, it returns an already completed stage, which means any additional dependent stages are run in the invoking thread.

      Specified by:
      continueOnNonBlockingThread in interface BlockingManager
      Type Parameters:
      V - return value type of the supplied stage.
      Parameters:
      delay - the stage to delay the continuation until complete.
      traceId - the identifier to print when tracing is enabled.
      Returns:
      a CompletionStage that, when depended upon, runs any callback in the supplied executor.

    • blockingPublisher

      public <V> org.reactivestreams.Publisher<V> blockingPublisher(org.reactivestreams.Publisher<V> publisher)
      Description copied from interface: BlockingManager
      Provided a publisher that is known to block when subscribed to. Thus if the thread that subscribes in a non blocking thread we will instead subscribe on a blocking thread and observe on a non blocking thread for each published value.

      If, however, the subscribing thread is a blocking thread no threading changes will be done, which means the publisher will be subscribed to on the invoking thread. In this case values have no guarantee as to which thread they are observed on, dependent solely on how the Publisher publishes them.

      Specified by:
      blockingPublisher in interface BlockingManager
      Type Parameters:
      V - the published entry types.
      Parameters:
      publisher - the publisher that, when subscribed to, blocks the current thread.
      Returns:
      publisher that does not block the current thread.

    • blockingPublisherToVoidStage

      public <V> CompletionStage<Void> blockingPublisherToVoidStage(org.reactivestreams.Publisher<V> publisher, Object traceId)
      Description copied from interface: BlockingManager
      Subscribes to the provided blocking publisher using the the blocking executor, ignoring all elements and returning a CompletionStage with a value of null which completes on a non-blocking thread. This method is designed to be used by a Publisher that when subscribed to has some type of side-effect that is blocking.

      The returned CompletionStage will always be completed upon a non-blocking thread if the current thread is non-blocking.

      Note that if the current thread is blocking everything including subscription, publication and collection of values will be done on the current thread.

      Specified by:
      blockingPublisherToVoidStage in interface BlockingManager
      Type Parameters:
      V - the published entry types.
      Parameters:
      publisher - the publisher that, when subscribed to, blocks the current thread.
      Returns:
      a completion stage that completes once the publisher has completed.

    • asExecutor

      public Executor asExecutor(String name)
      Description copied from interface: BlockingManager
      Returns an executor that will run the given tasks on a blocking thread as required.

      Note that this executor will always submit the task to the blocking thread pool, even if the requestor is a blocking thread. This is different than other methods that will invoke the task in the invoking thread if the invoking thread is blocking.

      Specified by:
      asExecutor in interface BlockingManager
      Returns:
      an executor that can run blocking commands.

    • limitedBlockingExecutor

      public BlockingManager.BlockingExecutor limitedBlockingExecutor(String name, int concurrentExecutions)
      Description copied from interface: BlockingManager
      Provides a BlockingManager.BlockingExecutor which is limited to the provided concurrency amount.
      Specified by:
      limitedBlockingExecutor in interface BlockingManager
      Parameters:
      name - name of the limited blocking executor.
      concurrentExecutions - maximum amount of concurrent operations to be performed via the returned executor.
      Returns:
      a blocking executor limited in the amount of concurrent invocations.

    • scheduleRunBlockingAtFixedRate

      public ScheduledFuture<?> scheduleRunBlockingAtFixedRate(Runnable runnable, long initialDelay, long period, TimeUnit unit, Object traceId)
      Specified by:
      scheduleRunBlockingAtFixedRate in interface BlockingManager

    • isCurrentThreadBlocking

      protected boolean isCurrentThreadBlocking()