Core functionality for the Reactor Netty library 1.1.16 · reactor.netty.resources.ColocatedEventLoopGroup

Modifier and Type	Field and Description
pack-priv final EventLoopGroup	eventLoopGroup
pack-priv final FastThreadLocal<EventLoop>	localLoop

Access	Constructor and Description
pack-priv	ColocatedEventLoopGroup(EventLoopGroup eventLoopGroup)

Method Summary

Modifier and Type	Method and Description
public boolean	awaitTermination(long the maximum time to wait timeout, TimeUnit the time unit of the timeout argument unit) Implements java.util.concurrent.ExecutorService.awaitTermination. Blocks until all tasks have completed execution after a shutdown request, or the timeout occurs, or the current thread is interrupted, whichever happens first.
pack-priv void	clean()
public void	execute(Runnable the runnable task command) Implements java.util.concurrent.Executor.execute. Executes the given command at some time in the future.
public EventLoopGroup	get() Implements java.util.function.Supplier.get. Gets a result.
public <T> List<Future<T>>	invokeAll(Collection<? extends Callable<T>> the collection of tasks tasks) Implements java.util.concurrent.ExecutorService.invokeAll. Executes the given tasks, returning a list of Futures holding their status and results when all complete.
public <T> List<Future<T>>	invokeAll(Collection<? extends Callable<T>> the collection of tasks tasks, long the maximum time to wait timeout, TimeUnit the time unit of the timeout argument unit) Implements java.util.concurrent.ExecutorService.invokeAll. Executes the given tasks, returning a list of Futures holding their status and results when all complete or the timeout expires, whichever happens first.
public <T> T	invokeAny(Collection<? extends Callable<T>> the collection of tasks tasks) Implements java.util.concurrent.ExecutorService.invokeAny. Executes the given tasks, returning the result of one that has completed successfully (i.e., without throwing an exception), if any do.
public <T> T	invokeAny(Collection<? extends Callable<T>> the collection of tasks tasks, long the maximum time to wait timeout, TimeUnit the time unit of the timeout argument unit) Implements java.util.concurrent.ExecutorService.invokeAny. Executes the given tasks, returning the result of one that has completed successfully (i.e., without throwing an exception), if any do before the given timeout elapses.
public boolean	isShutdown() Implements java.util.concurrent.ExecutorService.isShutdown. Returns `true` if this executor has been shut down.
public boolean	isShuttingDown() Implements io.netty.util.concurrent.EventExecutorGroup.isShuttingDown. Returns `true` if and only if all `EventExecutor`s managed by this `EventExecutorGroup` are being shut down gracefully or was shut down.
public boolean	isTerminated() Implements java.util.concurrent.ExecutorService.isTerminated. Returns `true` if all tasks have completed following shut down.
public Iterator<EventExecutor>	iterator() Implements io.netty.util.concurrent.EventExecutorGroup.iterator. Returns an iterator over elements of type `T`.
public EventLoop	next() Implements io.netty.channel.EventLoopGroup.next. Return the next `EventLoop` to use
pack-priv EventLoop	nextInternal()
public ChannelFuture	register(Channel channel) Implements io.netty.channel.EventLoopGroup.register. Register a `Channel` with this `EventLoop`.
public ChannelFuture	register(Channel channel, ChannelPromise promise) Implements io.netty.channel.EventLoopGroup.register. Deprecated Register a `Channel` with this `EventLoop`.
public ChannelFuture	register(ChannelPromise promise) Implements io.netty.channel.EventLoopGroup.register. Register a `Channel` with this `EventLoop` using a `ChannelFuture`.
public <V> ScheduledFuture<V>	schedule(Callable<V> the function to execute callable, long the time from now to delay execution delay, TimeUnit the time unit of the delay parameter unit) Implements io.netty.util.concurrent.EventExecutorGroup.schedule. Submits a value-returning one-shot task that becomes enabled after the given delay.
public ScheduledFuture<?>	schedule(Runnable the task to execute command, long the time from now to delay execution delay, TimeUnit the time unit of the delay parameter unit) Implements io.netty.util.concurrent.EventExecutorGroup.schedule. Submits a one-shot task that becomes enabled after the given delay.
public ScheduledFuture<?>	scheduleAtFixedRate(Runnable the task to execute command, long the time to delay first execution initialDelay, long the period between successive executions period, TimeUnit the time unit of the initialDelay and period parameters unit) Implements io.netty.util.concurrent.EventExecutorGroup.scheduleAtFixedRate. Submits a periodic action that becomes enabled first after the given initial delay, and subsequently with the given period; that is, executions will commence after `initialDelay`, then `initialDelay + period`, then `initialDelay + 2 * period`, and so on.
public ScheduledFuture<?>	scheduleWithFixedDelay(Runnable the task to execute command, long the time to delay first execution initialDelay, long the delay between the termination of one execution and the commencement of the next delay, TimeUnit the time unit of the initialDelay and delay parameters unit) Implements io.netty.util.concurrent.EventExecutorGroup.scheduleWithFixedDelay. Submits a periodic action that becomes enabled first after the given initial delay, and subsequently with the given delay between the termination of one execution and the commencement of the next.
public void	shutdown() Implements io.netty.util.concurrent.EventExecutorGroup.shutdown. Deprecated Initiates an orderly shutdown in which previously submitted tasks are executed, but no new tasks will be accepted.
public Future<?>	shutdownGracefully() Implements io.netty.util.concurrent.EventExecutorGroup.shutdownGracefully. Shortcut method for `shutdownGracefully(long, long, TimeUnit)` with sensible default values.
public Future<?>	shutdownGracefully(long the quiet period as described in the documentation quietPeriod, long the maximum amount of time to wait until the executor is shutdown() regardless if a task was submitted during the quiet period timeout, TimeUnit the unit of `quietPeriod` and `timeout` unit) Implements io.netty.util.concurrent.EventExecutorGroup.shutdownGracefully. Signals this executor that the caller wants the executor to be shut down.
public List<Runnable>	shutdownNow() Implements io.netty.util.concurrent.EventExecutorGroup.shutdownNow. Deprecated Attempts to stop all actively executing tasks, halts the processing of waiting tasks, and returns a list of the tasks that were awaiting execution.
public <T> Future<T>	submit(Callable<T> the task to submit task) Implements io.netty.util.concurrent.EventExecutorGroup.submit. Submits a value-returning task for execution and returns a Future representing the pending results of the task.
public Future<?>	submit(Runnable the task to submit task) Implements io.netty.util.concurrent.EventExecutorGroup.submit. Submits a Runnable task for execution and returns a Future representing that task.
public <T> Future<T>	submit(Runnable the task to submit task, T the result to return result) Implements io.netty.util.concurrent.EventExecutorGroup.submit. Submits a Runnable task for execution and returns a Future representing that task.
public Future<?>	terminationFuture() Implements io.netty.util.concurrent.EventExecutorGroup.terminationFuture. Returns the `Future` which is notified when all `EventExecutor`s managed by this `EventExecutorGroup` have been terminated.

Inherited from java.lang.Object:: clone equals finalize getClass hashCode notify notifyAll toString wait wait wait

eventLoopGroup	back to summary
pack-priv final EventLoopGroup eventLoopGroup

localLoop	back to summary
pack-priv final FastThreadLocal<EventLoop> localLoop

ColocatedEventLoopGroup	back to summary
pack-priv ColocatedEventLoopGroup(EventLoopGroup eventLoopGroup) Annotations @SuppressWarnings:FutureReturnValueIgnored

Method Detail

awaitTermination back to summary

awaitTermination	back to summary
public boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException Implements java.util.concurrent.ExecutorService.awaitTermination. Doc from java.util.concurrent.ExecutorService.awaitTermination. Blocks until all tasks have completed execution after a shutdown request, or the timeout occurs, or the current thread is interrupted, whichever happens first. Parameters timeout:long the maximum time to wait unit:TimeUnit the time unit of the timeout argument Returns:boolean `true` if this executor terminated and `false` if the timeout elapsed before termination Annotations @Override Exceptions InterruptedException: if interrupted while waiting

public boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException

Implements java.util.concurrent.ExecutorService.awaitTermination.

Doc from java.util.concurrent.ExecutorService.awaitTermination.

Blocks until all tasks have completed execution after a shutdown request, or the timeout occurs, or the current thread is interrupted, whichever happens first.

Parameters

timeout:long: the maximum time to wait
unit:TimeUnit: the time unit of the timeout argument

Returns:boolean

true if this executor terminated and false if the timeout elapsed before termination

Annotations

@Override

Exceptions

InterruptedException:: if interrupted while waiting

clean	back to summary
pack-priv void clean()

execute back to summary

execute	back to summary
public void execute(Runnable command) Implements java.util.concurrent.Executor.execute. Doc from java.util.concurrent.Executor.execute. Executes the given command at some time in the future. The command may execute in a new thread, in a pooled thread, or in the calling thread, at the discretion of the `Executor` implementation. Parameters command:Runnable the runnable task Annotations @Override

public void execute(Runnable command)

Implements java.util.concurrent.Executor.execute.

Doc from java.util.concurrent.Executor.execute.

Executes the given command at some time in the future. The command may execute in a new thread, in a pooled thread, or in the calling thread, at the discretion of the Executor implementation.

Parameters

command:Runnable: the runnable task

Annotations

@Override

get	back to summary
public EventLoopGroup get() Implements java.util.function.Supplier.get. Doc from java.util.function.Supplier.get. Gets a result. Returns:EventLoopGroup a result Annotations @Override

get

back to summary

public EventLoopGroup get()

Implements java.util.function.Supplier.get.

Doc from java.util.function.Supplier.get.

Gets a result.

Returns:EventLoopGroup

a result

Annotations

@Override

invokeAll back to summary

invokeAll	back to summary
public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks) throws InterruptedException Implements java.util.concurrent.ExecutorService.invokeAll. Doc from java.util.concurrent.ExecutorService.invokeAll. Executes the given tasks, returning a list of Futures holding their status and results when all complete. `Future#isDone` is `true` for each element of the returned list. Note that a completed task could have terminated either normally or by throwing an exception. The results of this method are undefined if the given collection is modified while this operation is in progress. Parameters <T> the type of the values returned from the tasks tasks:Collection<? extends Callable<T>> the collection of tasks Returns:List<Future<T>> a list of Futures representing the tasks, in the same sequential order as produced by the iterator for the given task list, each of which has completed Annotations @Override Exceptions InterruptedException: if interrupted while waiting, in which case unfinished tasks are cancelled

public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks) throws InterruptedException

Implements java.util.concurrent.ExecutorService.invokeAll.

Doc from java.util.concurrent.ExecutorService.invokeAll.

Executes the given tasks, returning a list of Futures holding their status and results when all complete. Future#isDone is true for each element of the returned list. Note that a completed task could have terminated either normally or by throwing an exception. The results of this method are undefined if the given collection is modified while this operation is in progress.

Parameters

<T>: the type of the values returned from the tasks
tasks:Collection<? extends Callable<T>>: the collection of tasks

Returns:List<Future<T>>

a list of Futures representing the tasks, in the same sequential order as produced by the iterator for the given task list, each of which has completed

Annotations

@Override

Exceptions

InterruptedException:: if interrupted while waiting, in which case unfinished tasks are cancelled

invokeAll back to summary

invokeAll	back to summary
public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit) throws InterruptedException Implements java.util.concurrent.ExecutorService.invokeAll. Doc from java.util.concurrent.ExecutorService.invokeAll. Executes the given tasks, returning a list of Futures holding their status and results when all complete or the timeout expires, whichever happens first. `Future#isDone` is `true` for each element of the returned list. Upon return, tasks that have not completed are cancelled. Note that a completed task could have terminated either normally or by throwing an exception. The results of this method are undefined if the given collection is modified while this operation is in progress. Parameters <T> the type of the values returned from the tasks tasks:Collection<? extends Callable<T>> the collection of tasks timeout:long the maximum time to wait unit:TimeUnit the time unit of the timeout argument Returns:List<Future<T>> a list of Futures representing the tasks, in the same sequential order as produced by the iterator for the given task list. If the operation did not time out, each task will have completed. If it did time out, some of these tasks will not have completed. Annotations @Override Exceptions InterruptedException: if interrupted while waiting, in which case unfinished tasks are cancelled

public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit) throws InterruptedException

Implements java.util.concurrent.ExecutorService.invokeAll.

Doc from java.util.concurrent.ExecutorService.invokeAll.

Executes the given tasks, returning a list of Futures holding their status and results when all complete or the timeout expires, whichever happens first. Future#isDone is true for each element of the returned list. Upon return, tasks that have not completed are cancelled. Note that a completed task could have terminated either normally or by throwing an exception. The results of this method are undefined if the given collection is modified while this operation is in progress.

Parameters

<T>: the type of the values returned from the tasks
tasks:Collection<? extends Callable<T>>: the collection of tasks
timeout:long: the maximum time to wait
unit:TimeUnit: the time unit of the timeout argument

Returns:List<Future<T>>

a list of Futures representing the tasks, in the same sequential order as produced by the iterator for the given task list. If the operation did not time out, each task will have completed. If it did time out, some of these tasks will not have completed.

Annotations

@Override

Exceptions

InterruptedException:: if interrupted while waiting, in which case unfinished tasks are cancelled

invokeAny	back to summary
public <T> T invokeAny(Collection<? extends Callable<T>> tasks) throws InterruptedException, ExecutionException Implements java.util.concurrent.ExecutorService.invokeAny. Doc from java.util.concurrent.ExecutorService.invokeAny. Executes the given tasks, returning the result of one that has completed successfully (i.e., without throwing an exception), if any do. Upon normal or exceptional return, tasks that have not completed are cancelled. The results of this method are undefined if the given collection is modified while this operation is in progress. Parameters <T> the type of the values returned from the tasks tasks:Collection<? extends Callable<T>> the collection of tasks Returns:T the result returned by one of the tasks Annotations @Override Exceptions InterruptedException: if interrupted while waiting ExecutionException: if no task successfully completes

invokeAny

back to summary

public <T> T invokeAny(Collection<? extends Callable<T>> tasks) throws InterruptedException, ExecutionException

Implements java.util.concurrent.ExecutorService.invokeAny.

Doc from java.util.concurrent.ExecutorService.invokeAny.

Executes the given tasks, returning the result of one that has completed successfully (i.e., without throwing an exception), if any do. Upon normal or exceptional return, tasks that have not completed are cancelled. The results of this method are undefined if the given collection is modified while this operation is in progress.

Parameters

<T>: the type of the values returned from the tasks
tasks:Collection<? extends Callable<T>>: the collection of tasks

Returns:T

the result returned by one of the tasks

Annotations

@Override

Exceptions

InterruptedException:: if interrupted while waiting
ExecutionException:: if no task successfully completes

invokeAny	back to summary
public <T> T invokeAny(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException Implements java.util.concurrent.ExecutorService.invokeAny. Doc from java.util.concurrent.ExecutorService.invokeAny. Executes the given tasks, returning the result of one that has completed successfully (i.e., without throwing an exception), if any do before the given timeout elapses. Upon normal or exceptional return, tasks that have not completed are cancelled. The results of this method are undefined if the given collection is modified while this operation is in progress. Parameters <T> the type of the values returned from the tasks tasks:Collection<? extends Callable<T>> the collection of tasks timeout:long the maximum time to wait unit:TimeUnit the time unit of the timeout argument Returns:T the result returned by one of the tasks Annotations @Override Exceptions InterruptedException: if interrupted while waiting ExecutionException: if no task successfully completes TimeoutException: if the given timeout elapses before any task successfully completes

invokeAny

back to summary

public <T> T invokeAny(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException

Implements java.util.concurrent.ExecutorService.invokeAny.

Doc from java.util.concurrent.ExecutorService.invokeAny.

Executes the given tasks, returning the result of one that has completed successfully (i.e., without throwing an exception), if any do before the given timeout elapses. Upon normal or exceptional return, tasks that have not completed are cancelled. The results of this method are undefined if the given collection is modified while this operation is in progress.

Parameters

<T>: the type of the values returned from the tasks
tasks:Collection<? extends Callable<T>>: the collection of tasks
timeout:long: the maximum time to wait
unit:TimeUnit: the time unit of the timeout argument

Returns:T

the result returned by one of the tasks

Annotations

@Override

Exceptions

InterruptedException:: if interrupted while waiting
ExecutionException:: if no task successfully completes
TimeoutException:: if the given timeout elapses before any task successfully completes

isShutdown back to summary

isShutdown	back to summary
public boolean isShutdown() Implements java.util.concurrent.ExecutorService.isShutdown. Doc from java.util.concurrent.ExecutorService.isShutdown. Returns `true` if this executor has been shut down. Returns:boolean `true` if this executor has been shut down Annotations @Override

public boolean isShutdown()

Implements java.util.concurrent.ExecutorService.isShutdown.

Doc from java.util.concurrent.ExecutorService.isShutdown.

Returns true if this executor has been shut down.

Returns:boolean

true if this executor has been shut down

Annotations

@Override

isShuttingDown back to summary

isShuttingDown	back to summary
public boolean isShuttingDown() Implements io.netty.util.concurrent.EventExecutorGroup.isShuttingDown. Doc from io.netty.util.concurrent.EventExecutorGroup.isShuttingDown. Returns `true` if and only if all `EventExecutor`s managed by this `EventExecutorGroup` are being shut down gracefully or was shut down. Annotations @Override

public boolean isShuttingDown()

Implements io.netty.util.concurrent.EventExecutorGroup.isShuttingDown.

Doc from io.netty.util.concurrent.EventExecutorGroup.isShuttingDown.

Returns true if and only if all EventExecutors managed by this EventExecutorGroup are being shut down gracefully or was shut down.

Annotations

@Override

isTerminated back to summary

isTerminated	back to summary
public boolean isTerminated() Implements java.util.concurrent.ExecutorService.isTerminated. Doc from java.util.concurrent.ExecutorService.isTerminated. Returns `true` if all tasks have completed following shut down. Note that `isTerminated` is never `true` unless either `shutdown` or `shutdownNow` was called first. Returns:boolean `true` if all tasks have completed following shut down Annotations @Override

public boolean isTerminated()

Implements java.util.concurrent.ExecutorService.isTerminated.

Doc from java.util.concurrent.ExecutorService.isTerminated.

Returns true if all tasks have completed following shut down. Note that isTerminated is never true unless either shutdown or shutdownNow was called first.

Returns:boolean

true if all tasks have completed following shut down

Annotations

@Override

iterator back to summary

iterator	back to summary
public Iterator<EventExecutor> iterator() Implements io.netty.util.concurrent.EventExecutorGroup.iterator. Doc from java.lang.Iterable.iterator. Returns an iterator over elements of type `T`. Returns:Iterator<EventExecutor> an Iterator. Annotations @Override

public Iterator<EventExecutor> iterator()

Implements io.netty.util.concurrent.EventExecutorGroup.iterator.

Doc from java.lang.Iterable.iterator.

Returns an iterator over elements of type T.

Returns:Iterator<EventExecutor>

an Iterator.

Annotations

@Override

next back to summary

next	back to summary
public EventLoop next() Implements io.netty.channel.EventLoopGroup.next. Doc from io.netty.channel.EventLoopGroup.next. Return the next `EventLoop` to use Annotations @Override

public EventLoop next()

Implements io.netty.channel.EventLoopGroup.next.

Doc from io.netty.channel.EventLoopGroup.next.

Return the next EventLoop to use

Annotations

@Override

nextInternal	back to summary
pack-priv EventLoop nextInternal() Annotations @Nullable

register	back to summary
public ChannelFuture register(Channel channel) Implements io.netty.channel.EventLoopGroup.register. Doc from io.netty.channel.EventLoopGroup.register. Register a `Channel` with this `EventLoop`. The returned `ChannelFuture` will get notified once the registration was complete. Annotations @Override

public ChannelFuture register(Channel channel)

Implements io.netty.channel.EventLoopGroup.register.

Doc from io.netty.channel.EventLoopGroup.register.

Register a Channel with this EventLoop. The returned ChannelFuture will get notified once the registration was complete.

Annotations

@Override

register	back to summary
public ChannelFuture register(Channel channel, ChannelPromise promise) Implements io.netty.channel.EventLoopGroup.register. Doc from io.netty.channel.EventLoopGroup.register. Deprecated Register a `Channel` with this `EventLoop`. The passed `ChannelFuture` will get notified once the registration was complete and also will get returned. Annotations @Deprecated @Override

public ChannelFuture register(Channel channel, ChannelPromise promise)

Implements io.netty.channel.EventLoopGroup.register.

Doc from io.netty.channel.EventLoopGroup.register.

Deprecated

Register a Channel with this EventLoop. The passed ChannelFuture will get notified once the registration was complete and also will get returned.

Annotations

@Deprecated
@Override

register	back to summary
public ChannelFuture register(ChannelPromise promise) Implements io.netty.channel.EventLoopGroup.register. Doc from io.netty.channel.EventLoopGroup.register. Register a `Channel` with this `EventLoop` using a `ChannelFuture`. The passed `ChannelFuture` will get notified once the registration was complete and also will get returned. Annotations @Override

public ChannelFuture register(ChannelPromise promise)

Implements io.netty.channel.EventLoopGroup.register.

Doc from io.netty.channel.EventLoopGroup.register.

Register a Channel with this EventLoop using a ChannelFuture. The passed ChannelFuture will get notified once the registration was complete and also will get returned.

Annotations

@Override

schedule	back to summary
public <V> ScheduledFuture<V> schedule(Callable<V> callable, long delay, TimeUnit unit) Implements io.netty.util.concurrent.EventExecutorGroup.schedule. Doc from java.util.concurrent.ScheduledExecutorService.schedule. Submits a value-returning one-shot task that becomes enabled after the given delay. Parameters <V> the type of the callable's result callable:Callable<V> the function to execute delay:long the time from now to delay execution unit:TimeUnit the time unit of the delay parameter Returns:ScheduledFuture<V> a ScheduledFuture that can be used to extract result or cancel Annotations @Override

schedule

back to summary

public <V> ScheduledFuture<V> schedule(Callable<V> callable, long delay, TimeUnit unit)

Implements io.netty.util.concurrent.EventExecutorGroup.schedule.

Doc from java.util.concurrent.ScheduledExecutorService.schedule.

Submits a value-returning one-shot task that becomes enabled after the given delay.

Parameters

<V>: the type of the callable's result
callable:Callable<V>: the function to execute
delay:long: the time from now to delay execution
unit:TimeUnit: the time unit of the delay parameter

Returns:ScheduledFuture<V>

a ScheduledFuture that can be used to extract result or cancel

Annotations

@Override

schedule back to summary

schedule	back to summary
public ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit) Implements io.netty.util.concurrent.EventExecutorGroup.schedule. Doc from java.util.concurrent.ScheduledExecutorService.schedule. Submits a one-shot task that becomes enabled after the given delay. Parameters command:Runnable the task to execute delay:long the time from now to delay execution unit:TimeUnit the time unit of the delay parameter Returns:ScheduledFuture<?> a ScheduledFuture representing pending completion of the task and whose `get()` method will return `null` upon completion Annotations @Override

public ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit)

Implements io.netty.util.concurrent.EventExecutorGroup.schedule.

Doc from java.util.concurrent.ScheduledExecutorService.schedule.

Submits a one-shot task that becomes enabled after the given delay.

Parameters

command:Runnable: the task to execute
delay:long: the time from now to delay execution
unit:TimeUnit: the time unit of the delay parameter

Returns:ScheduledFuture<?>

a ScheduledFuture representing pending completion of the task and whose get() method will return null upon completion

Annotations

@Override

scheduleAtFixedRate back to summary

scheduleAtFixedRate	back to summary
public ScheduledFuture<?> scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit) Implements io.netty.util.concurrent.EventExecutorGroup.scheduleAtFixedRate. Doc from java.util.concurrent.ScheduledExecutorService.scheduleAtFixedRate. Submits a periodic action that becomes enabled first after the given initial delay, and subsequently with the given period; that is, executions will commence after `initialDelay`, then `initialDelay + period`, then `initialDelay + 2 * period`, and so on. The sequence of task executions continues indefinitely until one of the following exceptional completions occur: The task is explicitly cancelled via the returned future. The executor terminates, also resulting in task cancellation. An execution of the task throws an exception. In this case calling `get` on the returned future will throw `ExecutionException`, holding the exception as its cause. Subsequent executions are suppressed. Subsequent calls to `isDone()` on the returned future will return `true`. If any execution of this task takes longer than its period, then subsequent executions may start late, but will not concurrently execute. Parameters command:Runnable the task to execute initialDelay:long the time to delay first execution period:long the period between successive executions unit:TimeUnit the time unit of the initialDelay and period parameters Returns:ScheduledFuture<?> a ScheduledFuture representing pending completion of the series of repeated tasks. The future's `get()` method will never return normally, and will throw an exception upon task cancellation or abnormal termination of a task execution. Annotations @Override

public ScheduledFuture<?> scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit)

Implements io.netty.util.concurrent.EventExecutorGroup.scheduleAtFixedRate.

Doc from java.util.concurrent.ScheduledExecutorService.scheduleAtFixedRate.

Submits a periodic action that becomes enabled first after the given initial delay, and subsequently with the given period; that is, executions will commence after initialDelay, then initialDelay + period, then initialDelay + 2 * period, and so on.

The sequence of task executions continues indefinitely until one of the following exceptional completions occur:

The task is explicitly cancelled via the returned future.
The executor terminates, also resulting in task cancellation.
An execution of the task throws an exception. In this case calling get on the returned future will throw ExecutionException, holding the exception as its cause.

Subsequent executions are suppressed. Subsequent calls to isDone() on the returned future will return true.

If any execution of this task takes longer than its period, then subsequent executions may start late, but will not concurrently execute.

Parameters

command:Runnable: the task to execute
initialDelay:long: the time to delay first execution
period:long: the period between successive executions
unit:TimeUnit: the time unit of the initialDelay and period parameters

Returns:ScheduledFuture<?>

a ScheduledFuture representing pending completion of the series of repeated tasks. The future's get() method will never return normally, and will throw an exception upon task cancellation or abnormal termination of a task execution.

Annotations

@Override

scheduleWithFixedDelay back to summary

scheduleWithFixedDelay	back to summary
public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit) Implements io.netty.util.concurrent.EventExecutorGroup.scheduleWithFixedDelay. Doc from java.util.concurrent.ScheduledExecutorService.scheduleWithFixedDelay. Submits a periodic action that becomes enabled first after the given initial delay, and subsequently with the given delay between the termination of one execution and the commencement of the next. The sequence of task executions continues indefinitely until one of the following exceptional completions occur: The task is explicitly cancelled via the returned future. The executor terminates, also resulting in task cancellation. An execution of the task throws an exception. In this case calling `get` on the returned future will throw `ExecutionException`, holding the exception as its cause. Subsequent executions are suppressed. Subsequent calls to `isDone()` on the returned future will return `true`. Parameters command:Runnable the task to execute initialDelay:long the time to delay first execution delay:long the delay between the termination of one execution and the commencement of the next unit:TimeUnit the time unit of the initialDelay and delay parameters Returns:ScheduledFuture<?> a ScheduledFuture representing pending completion of the series of repeated tasks. The future's `get()` method will never return normally, and will throw an exception upon task cancellation or abnormal termination of a task execution. Annotations @Override

public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit)

Implements io.netty.util.concurrent.EventExecutorGroup.scheduleWithFixedDelay.

Doc from java.util.concurrent.ScheduledExecutorService.scheduleWithFixedDelay.

Submits a periodic action that becomes enabled first after the given initial delay, and subsequently with the given delay between the termination of one execution and the commencement of the next.

The sequence of task executions continues indefinitely until one of the following exceptional completions occur:

The task is explicitly cancelled via the returned future.
The executor terminates, also resulting in task cancellation.
An execution of the task throws an exception. In this case calling get on the returned future will throw ExecutionException, holding the exception as its cause.

Subsequent executions are suppressed. Subsequent calls to isDone() on the returned future will return true.

Parameters

command:Runnable: the task to execute
initialDelay:long: the time to delay first execution
delay:long: the delay between the termination of one execution and the commencement of the next
unit:TimeUnit: the time unit of the initialDelay and delay parameters

Returns:ScheduledFuture<?>

Annotations

@Override

shutdown back to summary

shutdown	back to summary
public void shutdown() Implements io.netty.util.concurrent.EventExecutorGroup.shutdown. Doc from java.util.concurrent.ExecutorService.shutdown. Deprecated Initiates an orderly shutdown in which previously submitted tasks are executed, but no new tasks will be accepted. Invocation has no additional effect if already shut down. This method does not wait for previously submitted tasks to complete execution. Use `awaitTermination` to do that. Annotations @Deprecated @Override @SuppressWarnings:FutureReturnValueIgnored, InlineMeSuggester

public void shutdown()

Implements io.netty.util.concurrent.EventExecutorGroup.shutdown.

Doc from java.util.concurrent.ExecutorService.shutdown.

Deprecated

Initiates an orderly shutdown in which previously submitted tasks are executed, but no new tasks will be accepted. Invocation has no additional effect if already shut down.

This method does not wait for previously submitted tasks to complete execution. Use awaitTermination to do that.

Annotations

@Deprecated
@Override
@SuppressWarnings:FutureReturnValueIgnored, InlineMeSuggester

shutdownGracefully back to summary

shutdownGracefully	back to summary
public Future<?> shutdownGracefully() Implements io.netty.util.concurrent.EventExecutorGroup.shutdownGracefully. Doc from io.netty.util.concurrent.EventExecutorGroup.shutdownGracefully. Shortcut method for `shutdownGracefully(long, long, TimeUnit)` with sensible default values. Returns:Future<?> the `terminationFuture()` Annotations @Override

public Future<?> shutdownGracefully()

Implements io.netty.util.concurrent.EventExecutorGroup.shutdownGracefully.

Doc from io.netty.util.concurrent.EventExecutorGroup.shutdownGracefully.

Shortcut method for shutdownGracefully(long, long, TimeUnit) with sensible default values.

Returns:Future<?>

the terminationFuture()

Annotations

@Override

shutdownGracefully back to summary

shutdownGracefully	back to summary
public Future<?> shutdownGracefully(long quietPeriod, long timeout, TimeUnit unit) Implements io.netty.util.concurrent.EventExecutorGroup.shutdownGracefully. Doc from io.netty.util.concurrent.EventExecutorGroup.shutdownGracefully. Signals this executor that the caller wants the executor to be shut down. Once this method is called, `isShuttingDown()` starts to return `true`, and the executor prepares to shut itself down. Unlike `shutdown()`, graceful shutdown ensures that no tasks are submitted for 'the quiet period' (usually a couple seconds) before it shuts itself down. If a task is submitted during the quiet period, it is guaranteed to be accepted and the quiet period will start over. Parameters quietPeriod:long the quiet period as described in the documentation timeout:long the maximum amount of time to wait until the executor is shutdown() regardless if a task was submitted during the quiet period unit:TimeUnit the unit of `quietPeriod` and `timeout` Returns:Future<?> the `terminationFuture()` Annotations @Override

public Future<?> shutdownGracefully(long quietPeriod, long timeout, TimeUnit unit)

Implements io.netty.util.concurrent.EventExecutorGroup.shutdownGracefully.

Doc from io.netty.util.concurrent.EventExecutorGroup.shutdownGracefully.

Signals this executor that the caller wants the executor to be shut down. Once this method is called, isShuttingDown() starts to return true, and the executor prepares to shut itself down. Unlike shutdown(), graceful shutdown ensures that no tasks are submitted for 'the quiet period' (usually a couple seconds) before it shuts itself down. If a task is submitted during the quiet period, it is guaranteed to be accepted and the quiet period will start over.

Parameters

quietPeriod:long: the quiet period as described in the documentation
timeout:long: the maximum amount of time to wait until the executor is shutdown() regardless if a task was submitted during the quiet period
unit:TimeUnit: the unit of quietPeriod and timeout

Returns:Future<?>

the terminationFuture()

Annotations

@Override

shutdownNow back to summary

shutdownNow	back to summary
public List<Runnable> shutdownNow() Implements io.netty.util.concurrent.EventExecutorGroup.shutdownNow. Doc from java.util.concurrent.ExecutorService.shutdownNow. Deprecated Attempts to stop all actively executing tasks, halts the processing of waiting tasks, and returns a list of the tasks that were awaiting execution. This method does not wait for actively executing tasks to terminate. Use `awaitTermination` to do that. There are no guarantees beyond best-effort attempts to stop processing actively executing tasks. For example, typical implementations will cancel via `Thread#interrupt`, so any task that fails to respond to interrupts may never terminate. Returns:List<Runnable> list of tasks that never commenced execution Annotations @Override @Deprecated

public List<Runnable> shutdownNow()

Implements io.netty.util.concurrent.EventExecutorGroup.shutdownNow.

Doc from java.util.concurrent.ExecutorService.shutdownNow.

Deprecated

Attempts to stop all actively executing tasks, halts the processing of waiting tasks, and returns a list of the tasks that were awaiting execution.

This method does not wait for actively executing tasks to terminate. Use awaitTermination to do that.

There are no guarantees beyond best-effort attempts to stop processing actively executing tasks. For example, typical implementations will cancel via Thread#interrupt, so any task that fails to respond to interrupts may never terminate.

Returns:List<Runnable>

list of tasks that never commenced execution

Annotations

@Override
@Deprecated

submit back to summary

submit	back to summary
public <T> Future<T> submit(Callable<T> task) Implements io.netty.util.concurrent.EventExecutorGroup.submit. Doc from java.util.concurrent.ExecutorService.submit. Submits a value-returning task for execution and returns a Future representing the pending results of the task. The Future's `get` method will return the task's result upon successful completion. If you would like to immediately block waiting for a task, you can use constructions of the form `result = exec.submit(aCallable).get();` Note The `Executors` class includes a set of methods that can convert some other common closure-like objects, for example, `java.security.PrivilegedAction` to `Callable` form so they can be submitted. Parameters <T> the type of the task's result task:Callable<T> the task to submit Returns:Future<T> a Future representing pending completion of the task Annotations @Override

public <T> Future<T> submit(Callable<T> task)

Implements io.netty.util.concurrent.EventExecutorGroup.submit.

Doc from java.util.concurrent.ExecutorService.submit.

Submits a value-returning task for execution and returns a Future representing the pending results of the task. The Future's get method will return the task's result upon successful completion.

If you would like to immediately block waiting for a task, you can use constructions of the form result = exec.submit(aCallable).get();

Note

The Executors class includes a set of methods that can convert some other common closure-like objects, for example, java.security.PrivilegedAction to Callable form so they can be submitted.

Parameters

<T>: the type of the task's result
task:Callable<T>: the task to submit

Returns:Future<T>

a Future representing pending completion of the task

Annotations

@Override

submit back to summary

submit	back to summary
public Future<?> submit(Runnable task) Implements io.netty.util.concurrent.EventExecutorGroup.submit. Doc from java.util.concurrent.ExecutorService.submit. Submits a Runnable task for execution and returns a Future representing that task. The Future's `get` method will return `null` upon successful completion. Parameters task:Runnable the task to submit Returns:Future<?> a Future representing pending completion of the task Annotations @Override

public Future<?> submit(Runnable task)

Implements io.netty.util.concurrent.EventExecutorGroup.submit.

Doc from java.util.concurrent.ExecutorService.submit.

Submits a Runnable task for execution and returns a Future representing that task. The Future's get method will return null upon successful completion.

Parameters

task:Runnable: the task to submit

Returns:Future<?>

a Future representing pending completion of the task

Annotations

@Override

submit back to summary

submit	back to summary
public <T> Future<T> submit(Runnable task, T result) Implements io.netty.util.concurrent.EventExecutorGroup.submit. Doc from java.util.concurrent.ExecutorService.submit. Submits a Runnable task for execution and returns a Future representing that task. The Future's `get` method will return the given result upon successful completion. Parameters <T> the type of the result task:Runnable the task to submit result:T the result to return Returns:Future<T> a Future representing pending completion of the task Annotations @Override

public <T> Future<T> submit(Runnable task, T result)

Implements io.netty.util.concurrent.EventExecutorGroup.submit.

Doc from java.util.concurrent.ExecutorService.submit.

Submits a Runnable task for execution and returns a Future representing that task. The Future's get method will return the given result upon successful completion.

Parameters

<T>: the type of the result
task:Runnable: the task to submit
result:T: the result to return

Returns:Future<T>

a Future representing pending completion of the task

Annotations

@Override

terminationFuture back to summary

terminationFuture	back to summary
public Future<?> terminationFuture() Implements io.netty.util.concurrent.EventExecutorGroup.terminationFuture. Doc from io.netty.util.concurrent.EventExecutorGroup.terminationFuture. Returns the `Future` which is notified when all `EventExecutor`s managed by this `EventExecutorGroup` have been terminated. Annotations @Override

public Future<?> terminationFuture()

Implements io.netty.util.concurrent.EventExecutorGroup.terminationFuture.

Doc from io.netty.util.concurrent.EventExecutorGroup.terminationFuture.

Returns the Future which is notified when all EventExecutors managed by this EventExecutorGroup have been terminated.

Annotations

@Override

pack-priv final Class ColocatedEventLoopGroup

Field Summary

Constructor Summary

Method Summary

Field Detail

Constructor Detail

Method Detail