org.apache.flink.streaming.runtime.tasks

Class ProcessingTimeService

java.lang.Object

org.apache.flink.streaming.runtime.tasks.ProcessingTimeService

Direct Known Subclasses:

SystemProcessingTimeService, TestProcessingTimeService

public abstract class ProcessingTimeService
extends Object

Defines the current processing time and handles all related actions, such as register timers for tasks to be executed in the future.

The access to the time via getCurrentProcessingTime() is always available, regardless of whether the timer service has been shut down.

The registration of timers follows a life cycle of three phases:

1. In the initial state, it accepts timer registrations and triggers when the time is reached.
2. After calling quiesce(), further calls to registerTimer(long, ProcessingTimeCallback) will not register any further timers, and will return a "dummy" future as a result. This is used for clean shutdown, where currently firing timers are waited for and no future timers can be scheduled, without causing hard exceptions.
3. After a call to shutdownService(), all calls to registerTimer(long, ProcessingTimeCallback) will result in a hard exception.

Constructor Summary

Constructors

Constructor and Description
ProcessingTimeService()

Method Summary

Modifier and Type	Method and Description
abstract void	awaitPendingAfterQuiesce() This method can be used after calling quiesce(), and awaits the completion of currently executing timers.
abstract long	getCurrentProcessingTime() Returns the current processing time.
abstract boolean	isTerminated() Returns true if the service has been shut down, false otherwise.
abstract void	quiesce() This method puts the service into a state where it does not register new timers, but returns for each call to registerTimer(long, ProcessingTimeCallback) only a "mock" future.
abstract ScheduledFuture<?>	registerTimer(long timestamp, ProcessingTimeCallback target) Registers a task to be executed when (processing) time is timestamp.
abstract ScheduledFuture<?>	scheduleAtFixedRate(ProcessingTimeCallback callback, long initialDelay, long period) Registers a task to be executed repeatedly at a fixed rate.
abstract boolean	shutdownAndAwaitPending(long time, TimeUnit timeUnit) Shuts down and clean up the timer service provider hard and immediately.
abstract void	shutdownService() Shuts down and clean up the timer service provider hard and immediately.
abstract boolean	shutdownServiceUninterruptible(long timeoutMs) Shuts down and clean up the timer service provider hard and immediately.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

ProcessingTimeService

public ProcessingTimeService()

Method Detail

getCurrentProcessingTime

public abstract long getCurrentProcessingTime()

Returns the current processing time.

registerTimer

public abstract ScheduledFuture<?> registerTimer(long timestamp,
                                                 ProcessingTimeCallback target)

Registers a task to be executed when (processing) time is timestamp.

Parameters:

timestamp - Time when the task is to be executed (in processing time)

target - The task to be executed

Returns:

The future that represents the scheduled task. This always returns some future, even if the timer was shut down

scheduleAtFixedRate

public abstract ScheduledFuture<?> scheduleAtFixedRate(ProcessingTimeCallback callback,
                                                       long initialDelay,
                                                       long period)

Registers a task to be executed repeatedly at a fixed rate.

Parameters:

callback - to be executed after the initial delay and then after each period

initialDelay - initial delay to start executing callback

period - after the initial delay after which the callback is executed

Returns:

Scheduled future representing the task to be executed repeatedly

isTerminated

public abstract boolean isTerminated()

Returns true if the service has been shut down, false otherwise.

quiesce

public abstract void quiesce()
                      throws InterruptedException

This method puts the service into a state where it does not register new timers, but returns for each call to registerTimer(long, ProcessingTimeCallback) only a "mock" future. Furthermore, the method clears all not yet started timers.

This method can be used to cleanly shut down the timer service. The using components will not notice that the service is shut down (as for example via exceptions when registering a new timer), but the service will simply not fire any timer any more.

Throws:

InterruptedException

awaitPendingAfterQuiesce

public abstract void awaitPendingAfterQuiesce()
                                       throws InterruptedException

This method can be used after calling quiesce(), and awaits the completion of currently executing timers.

Throws:

InterruptedException

shutdownService

public abstract void shutdownService()

Shuts down and clean up the timer service provider hard and immediately. This does not wait for any timer to complete. Any further call to registerTimer(long, ProcessingTimeCallback) will result in a hard exception.

shutdownServiceUninterruptible

public abstract boolean shutdownServiceUninterruptible(long timeoutMs)

Shuts down and clean up the timer service provider hard and immediately. This does not wait for any timer to complete. Any further call to registerTimer(long, ProcessingTimeCallback) will result in a hard exception. This call cannot be interrupted and will block until the shutdown is completed or the timeout is exceeded.

Parameters:

timeoutMs - timeout for blocking on the service shutdown in milliseconds.

Returns:

returns true iff the shutdown was completed.

shutdownAndAwaitPending

public abstract boolean shutdownAndAwaitPending(long time,
                                                TimeUnit timeUnit)
                                         throws InterruptedException

Shuts down and clean up the timer service provider hard and immediately. This does wait for all timers to complete or until the time limit is exceeded. Any call to registerTimer(long, ProcessingTimeCallback) will result in a hard exception after calling this method.

Parameters:

time - time to wait for termination.

timeUnit - time unit of parameter time.

Returns:

true if this timer service and all pending timers are terminated and false if the timeout elapsed before this happened.

Throws:

InterruptedException