Package io.reactivex.rxjava3.internal.schedulers

Class SingleScheduler

  • public final class SingleScheduler
extends Scheduler
    A scheduler with a shared, single threaded underlying ScheduledExecutorService.
    Since:
    2.0

    • Field Summary

      Fields 
      Modifier and Type Field Description
      (package private) java.util.concurrent.atomic.AtomicReference<java.util.concurrent.ScheduledExecutorService> executor  
      private static java.lang.String KEY_SINGLE_PRIORITY
      The name of the system property for setting the thread priority for this Scheduler.
      (package private) static java.util.concurrent.ScheduledExecutorService SHUTDOWN  
      (package private) static RxThreadFactory SINGLE_THREAD_FACTORY  
      private static java.lang.String THREAD_NAME_PREFIX  
      (package private) java.util.concurrent.ThreadFactory threadFactory  

    • Constructor Summary

      Constructors 
      Constructor Description
      SingleScheduler()  
      SingleScheduler​(java.util.concurrent.ThreadFactory threadFactory)
      Constructs a SingleScheduler with the given ThreadFactory and prepares the single scheduler thread.

    • Field Detail

      • threadFactory

        final java.util.concurrent.ThreadFactory threadFactory

      • executor

        final java.util.concurrent.atomic.AtomicReference<java.util.concurrent.ScheduledExecutorService> executor

      • KEY_SINGLE_PRIORITY

        private static final java.lang.String KEY_SINGLE_PRIORITY
        The name of the system property for setting the thread priority for this Scheduler.
        See Also:
        Constant Field Values

      • THREAD_NAME_PREFIX

        private static final java.lang.String THREAD_NAME_PREFIX
        See Also:
        Constant Field Values

      • SINGLE_THREAD_FACTORY

        static final RxThreadFactory SINGLE_THREAD_FACTORY

      • SHUTDOWN

        static final java.util.concurrent.ScheduledExecutorService SHUTDOWN

    • Constructor Detail

      • SingleScheduler

        public SingleScheduler()

      • SingleScheduler

        public SingleScheduler​(java.util.concurrent.ThreadFactory threadFactory)
        Constructs a SingleScheduler with the given ThreadFactory and prepares the single scheduler thread.
        Parameters:
        threadFactory - thread factory to use for creating worker threads. Note that this takes precedence over any system properties for configuring new thread creation. Cannot be null.

    • Method Detail

      • createExecutor

        static java.util.concurrent.ScheduledExecutorService createExecutor​(java.util.concurrent.ThreadFactory threadFactory)

      • start

        public void start()
        Description copied from class: Scheduler
        Allows the Scheduler instance to start threads and accept tasks on them.

        Implementations should make sure the call is idempotent, thread-safe and should not throw any RuntimeException if it doesn't support this functionality.

        Overrides:
        start in class Scheduler

      • shutdown

        public void shutdown()
        Description copied from class: Scheduler
        Instructs the Scheduler instance to stop threads, stop accepting tasks on any outstanding Scheduler.Worker instances and clean up any associated resources with this Scheduler.

        Implementations should make sure the call is idempotent, thread-safe and should not throw any RuntimeException if it doesn't support this functionality.

        Overrides:
        shutdown in class Scheduler

      • createWorker

        @NonNull
public @NonNull Scheduler.Worker createWorker()
        Description copied from class: Scheduler
        Retrieves or creates a new Scheduler.Worker that represents sequential execution of actions.

        When work is completed, the Worker instance should be released by calling Disposable.dispose() to avoid potential resource leaks in the underlying task-execution scheme.

        Work on a Scheduler.Worker is guaranteed to be sequential and non-overlapping.

        Specified by:
        createWorker in class Scheduler
        Returns:
        a Worker representing a serial queue of actions to be executed

      • scheduleDirect

        @NonNull
public @NonNull Disposable scheduleDirect​(@NonNull
                                          @NonNull java.lang.Runnable run,
                                          long delay,
                                          java.util.concurrent.TimeUnit unit)
        Description copied from class: Scheduler
        Schedules the execution of the given task with the given time delay.

        This method is safe to be called from multiple threads but there are no ordering guarantees between tasks.

        Overrides:
        scheduleDirect in class Scheduler
        Parameters:
        run - the task to schedule
        delay - the delay amount, non-positive values indicate non-delayed scheduling
        unit - the unit of measure of the delay amount
        Returns:
        the Disposable that let's one cancel this particular delayed task.

      • schedulePeriodicallyDirect

        @NonNull
public @NonNull Disposable schedulePeriodicallyDirect​(@NonNull
                                                      @NonNull java.lang.Runnable run,
                                                      long initialDelay,
                                                      long period,
                                                      java.util.concurrent.TimeUnit unit)
        Description copied from class: Scheduler
        Schedules a periodic execution of the given task with the given initial time delay and repeat period.

        This method is safe to be called from multiple threads but there are no ordering guarantees between tasks.

        The periodic execution is at a fixed rate, that is, the first execution will be after the initialDelay, the second after initialDelay + period, the third after initialDelay + 2 * period, and so on.

        Overrides:
        schedulePeriodicallyDirect in class Scheduler
        Parameters:
        run - the task to schedule
        initialDelay - the initial delay amount, non-positive values indicate non-delayed scheduling
        period - the period at which the task should be re-executed
        unit - the unit of measure of the delay amount
        Returns:
        the Disposable that let's one cancel this particular delayed task.