Class

monix.execution.Scheduler

Extensions

Related Doc: package Scheduler

Permalink

implicit final class Extensions extends AnyVal with ExecuteExtensions

Utilities complementing the Scheduler interface.

Linear Supertypes
ExecuteExtensions, AnyVal, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. Extensions
  2. ExecuteExtensions
  3. AnyVal
  4. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Instance Constructors

  1. new Extensions(source: Scheduler)

    Permalink

Value Members

  1. final def !=(arg0: Any): Boolean

    Permalink
    Definition Classes
    Any
  2. final def ##(): Int

    Permalink
    Definition Classes
    Any
  3. final def ==(arg0: Any): Boolean

    Permalink
    Definition Classes
    Any
  4. final def asInstanceOf[T0]: T0

    Permalink
    Definition Classes
    Any
  5. def clock[F[_]](implicit F: Sync[F]): Clock[F]

    Permalink

    Derives a cats.effect.Clock from Scheduler for any data type that has a cats.effect.LiftIO implementation.

  6. def contextShift[F[_]](implicit F: Async[F]): ContextShift[F]

    Permalink

    Derives a cats.effect.ContextShift from Scheduler for any data type that has a cats.effect.Effect implementation.

    Derives a cats.effect.ContextShift from Scheduler for any data type that has a cats.effect.Effect implementation.

    val contextShift: ContextShift[IO] = scheduler.contextShift[IO]
    val executor = Executors.newCachedThreadPool()
    val ec = ExecutionContext.fromExecutor(executor)
    
    contextShift.evalOn(ec)(IO(println("I'm on different thread pool!"))
      .flatMap { _ =>
        IO(println("I came back to default"))
      }
  7. def executeAsync(cb: () ⇒ Unit): Unit

    Permalink

    Schedules the given callback for asynchronous execution in the thread-pool.

    Schedules the given callback for asynchronous execution in the thread-pool.

    On Scala < 2.12 it is described as a macro, so it has zero overhead, being perfectly equivalent with execute(new Runnable { ... }).

    On Scala 2.12 because of the Java 8 SAM types integration, this extension macro is replaced with a method that takes a plain Runnable as parameter.

    cb

    the callback to execute asynchronously

    Definition Classes
    ExecuteExtensions
  8. def executeAsyncBatch(cb: () ⇒ Unit): Unit

    Permalink

    Schedules the given callback for asynchronous execution in the thread-pool, but also indicates the start of a thread-local trampoline in case the scheduler is a BatchingScheduler.

    Schedules the given callback for asynchronous execution in the thread-pool, but also indicates the start of a thread-local trampoline in case the scheduler is a BatchingScheduler.

    This utility is provided as an optimization. If you don't understand what this does, then don't worry about it.

    On Scala < 2.12 it is described as a macro, so it has zero overhead. On Scala 2.12 because of the Java 8 SAM types integration, this extension macro is replaced with a method that takes a plain TrampolinedRunnable as parameter.

    cb

    the callback to execute asynchronously

    Definition Classes
    ExecuteExtensions
  9. def executeTrampolined(cb: () ⇒ Unit): Unit

    Permalink

    Schedules the given callback for immediate execution as a TrampolinedRunnable.

    Schedules the given callback for immediate execution as a TrampolinedRunnable. Depending on the execution context, it might get executed on the current thread by using an internal trampoline, so it is still safe from stack-overflow exceptions.

    On Scala < 2.12 it is described as a macro, so it has zero overhead, being perfectly equivalent with execute(new TrampolinedRunnable { ... }).

    On Scala 2.12 because of the Java 8 SAM types integration, this extension macro is replaced with a method that takes a plain TrampolinedRunnable as parameter.

    cb

    the callback to execute asynchronously

    Definition Classes
    ExecuteExtensions
  10. def getClass(): Class[_ <: AnyVal]

    Permalink
    Definition Classes
    AnyVal → Any
  11. final def isInstanceOf[T0]: Boolean

    Permalink
    Definition Classes
    Any
  12. def scheduleAtFixedRate(initialDelay: FiniteDuration, period: FiniteDuration)(action: ⇒ Unit): Cancelable

    Permalink

    Schedules a periodic task that becomes enabled first after the given initial delay, and subsequently with the given period.

    Schedules a periodic task that becomes enabled first after the given initial delay, and subsequently with the given period. Executions will commence after initialDelay then initialDelay + period, then initialDelay + 2 * period and so on.

    If any execution of the task encounters an exception, subsequent executions are suppressed. Otherwise, the task will only terminate via cancellation or termination of the scheduler. If any execution of this task takes longer than its period, then subsequent executions may start late, but will not concurrently execute.

    For example the following schedules a message to be printed to standard output approximately every 10 seconds with an initial delay of 5 seconds:

    val task = scheduler.scheduleAtFixedRate(5.seconds, 10.seconds) {
      print("Repeated message")
    }
    
    // later if you change your mind ...
    task.cancel()
    initialDelay

    is the time to wait until the first execution happens

    period

    is the time to wait between 2 successive executions of the task

    action

    is the callback to be executed

    returns

    a cancelable that can be used to cancel the execution of this repeated task at any time.

  13. def scheduleOnce(initialDelay: FiniteDuration)(action: ⇒ Unit): Cancelable

    Permalink

    Schedules a task to run in the future, after initialDelay.

    Schedules a task to run in the future, after initialDelay.

    For example the following schedules a message to be printed to standard output after 5 minutes:

    val task = scheduler.scheduleOnce(5.minutes) {
      print("Hello, world!")
    }
    
    // later, if you change your mind ...
    task.cancel()
    initialDelay

    is the time to wait until the execution happens

    action

    is the callback to be executed

    returns

    a Cancelable that can be used to cancel the created task before execution.

  14. def scheduleWithFixedDelay(initialDelay: FiniteDuration, delay: FiniteDuration)(action: ⇒ Unit): Cancelable

    Permalink

    Schedules for execution a periodic task that is first executed after the given initial delay and subsequently with the given delay between the termination of one execution and the commencement of the next.

    Schedules for execution a periodic task that is first executed after the given initial delay and subsequently with the given delay between the termination of one execution and the commencement of the next.

    For example the following schedules a message to be printed to standard output every 10 seconds with an initial delay of 5 seconds:

    val task = s.scheduleWithFixedDelay(5.seconds, 10.seconds) {
      print("Repeated message")
    }
    
    // later if you change your mind ...
    task.cancel()
    initialDelay

    is the time to wait until the first execution happens

    delay

    is the time to wait between 2 successive executions of the task

    action

    is the callback to be executed

    returns

    a cancelable that can be used to cancel the execution of this repeated task at any time.

  15. val source: Scheduler

    Permalink
    Definition Classes
    Extensions → ExecuteExtensions
  16. def timer[F[_]](implicit F: Concurrent[F]): Timer[F]

    Permalink

    Derives a cats.effect.Timer from Scheduler for any data type that has a cats.effect.Concurrent type class instance.

    Derives a cats.effect.Timer from Scheduler for any data type that has a cats.effect.Concurrent type class instance.

    implicit val timer: Timer[IO] = scheduler.timer[IO]
    
    IO.sleep(10.seconds).flatMap { _ =>
      IO(println("Delayed hello!"))
    }
  17. def timerLiftIO[F[_]](implicit F: LiftIO[F]): Timer[F]

    Permalink

    Derives a cats.effect.Timer from Scheduler for any data type that has a cats.effect.LiftIO instance.

    Derives a cats.effect.Timer from Scheduler for any data type that has a cats.effect.LiftIO instance.

    This is the relaxed timer method, needing only LiftIO to work, by piggybacking on cats.effect.IO.

    implicit val timer: Timer[IO] = scheduler.timerLiftIO[IO]
    
    IO.sleep(10.seconds).flatMap { _ =>
      IO(println("Delayed hello!"))
    }
  18. def toString(): String

    Permalink
    Definition Classes
    Any

Deprecated Value Members

  1. def currentTimeMillis(): Long

    Permalink

    DEPRECATED — use clockRealTime(MILLISECONDS).

    DEPRECATED — use clockRealTime(MILLISECONDS).

    Annotations
    @deprecated
    Deprecated

    (Since version 3.0.0) Use clockRealTime(MILLISECONDS)

Inherited from ExecuteExtensions

Inherited from AnyVal

Inherited from Any

Ungrouped