Package io.microraft.executor

Interface RaftNodeExecutor

public interface RaftNodeExecutor

The abstraction used by RaftNode to execute the Raft consensus algorithm with the Actor model. You can read about the Actor Model at the following link: https://en.wikipedia.org/wiki/Actor_model

A Raft node runs by submitting tasks to its Raft node executor. All tasks submitted by a Raft node must be executed serially, with maintaining the happens-before relationship, so that the Raft consensus algorithm and the user-provided state machine logic could be executed without synchronization.

A default implementation, DefaultRaftNodeExecutor is provided and should be suitable for most of the use-cases.

A RaftNodeExecutor implementation can implement RaftNodeLifecycleAware to perform initialization and clean up work during RaftNode startup and termination. However, there is one subtle point about the order of method calls. RaftNode calls execute(Runnable) before RaftNodeLifecycleAware.onRaftNodeStart() to submit the start task.

See Also:

RaftNode, DefaultRaftNodeExecutor, RaftNodeLifecycleAware

Method Summary

Modifier and Type	Method	Description
void	execute(Runnable task)	Executes the given task on the underlying platform.
void	schedule(Runnable task, long delay, TimeUnit timeUnit)	Schedules the task on the underlying platform to be executed after the given delay.
void	submit(Runnable task)	Submits the given task for execution.

Method Detail

execute

void execute(@Nonnull
             Runnable task)

Executes the given task on the underlying platform.

Please note that all tasks of a single Raft node must be executed in a single-threaded manner and the happens-before relationship must be maintained between given tasks of the Raft node.

The underlying platform is free to execute the given task immediately if it fits to the defined guarantees.

Parameters:

task - the task to be executed.

submit

void submit(@Nonnull
            Runnable task)

Submits the given task for execution.

If the caller is already on the thread that runs the Raft node, the given task cannot be executed immediately and it must be put into the internal task queue for execution in future.

Parameters:

task - the task object to be executed later.

schedule

void schedule(@Nonnull
              Runnable task,
              long delay,
              @Nonnull
              TimeUnit timeUnit)

Schedules the task on the underlying platform to be executed after the given delay.

Please note that even though the scheduling can be offloaded to another thread, the given task must be executed in a single-threaded manner and the happens-before relationship must be maintained between given tasks of the Raft node.

Parameters:

task - the task to be executed in future

delay - the time from now to delay execution

timeUnit - the time unit of the delay