Netty 4.1.107.Final · io.netty.util.concurrent.AbstractEventExecutorGroup

Access	Constructor and Description
public	AbstractEventExecutorGroup()

Method Summary

Modifier and Type	Method and Description
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 <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 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 <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<?>	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 abstract void	shutdown() Redeclares io.netty.util.concurrent.EventExecutorGroup.shutdown. Deprecated `shutdownGracefully(long, long, TimeUnit)` or `shutdownGracefully()` instead. 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 List<Runnable>	shutdownNow() Implements io.netty.util.concurrent.EventExecutorGroup.shutdownNow. Deprecated `shutdownGracefully(long, long, TimeUnit)` or `shutdownGracefully()` instead. 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 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 <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.

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

AbstractEventExecutorGroup	back to summary
public AbstractEventExecutorGroup()

Method Detail

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

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

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

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

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 abstract void shutdown() Redeclares io.netty.util.concurrent.EventExecutorGroup.shutdown. Doc from java.util.concurrent.ExecutorService.shutdown. Deprecated `shutdownGracefully(long, long, TimeUnit)` or `shutdownGracefully()` instead. 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 @Override @Deprecated

public abstract void shutdown()

Redeclares io.netty.util.concurrent.EventExecutorGroup.shutdown.

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

Deprecated

shutdownGracefully(long, long, TimeUnit) or shutdownGracefully() instead.

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

@Override
@Deprecated

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

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 `shutdownGracefully(long, long, TimeUnit)` or `shutdownGracefully()` instead. 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

shutdownGracefully(long, long, TimeUnit) or shutdownGracefully() instead.

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 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

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

public abstract Class AbstractEventExecutorGroup

Constructor Summary

Method Summary

Constructor Detail

Method Detail