java.lang.Object
- java.util.concurrent.AbstractExecutorService
- - io.netty.util.concurrent.AbstractEventExecutor
  - - io.netty.util.concurrent.AbstractScheduledEventExecutor
    - - io.netty.channel.embedded.EmbeddedEventLoop

All Implemented Interfaces:

EventLoop, EventLoopGroup, EventExecutor, EventExecutorGroup, OrderedEventExecutor, ThreadAwareExecutor, java.lang.Iterable<EventExecutor>, java.util.concurrent.Executor, java.util.concurrent.ExecutorService, java.util.concurrent.ScheduledExecutorService
```
final class EmbeddedEventLoop
extends AbstractScheduledEventExecutor
implements EventLoop
```

Nested Class Summary

Nested Classes
Modifier and Type Class Description

(package private) static class EmbeddedEventLoop.FreezableTicker
Ticker that implements the old EmbeddedChannel time freezing mechanics.
- Nested classes/interfaces inherited from class io.netty.util.concurrent.AbstractEventExecutor
  AbstractEventExecutor.LazyRunnable

Field Summary

Fields
Modifier and Type Field Description

private java.util.Queue<java.lang.Runnable> tasks

private Ticker ticker

Constructor Summary

Constructors
Constructor Description

EmbeddedEventLoop(Ticker ticker)

Method Summary

All Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method	Description
`boolean`	`awaitTermination(long timeout, java.util.concurrent.TimeUnit unit)`
`protected void`	`cancelScheduledTasks()`	Cancel all scheduled tasks.
`void`	`execute(java.lang.Runnable command)`
`protected long`	`getCurrentTimeNanos()`	Get the current time in nanoseconds by this executor's clock.
`(package private) boolean`	`hasPendingNormalTasks()`
`boolean`	`inEventLoop()`	Calls `EventExecutor.inEventLoop(Thread)` with `Thread.currentThread()` as argument
`boolean`	`inEventLoop(java.lang.Thread thread)`	Return `true` if the given `Thread` is executed in the event loop, `false` otherwise.
`boolean`	`isShutdown()`
`boolean`	`isShuttingDown()`	Returns `true` if and only if all `EventExecutor`s managed by this `EventExecutorGroup` are being shut down gracefully or was shut down.
`boolean`	`isTerminated()`
`EventLoop`	`next()`	Returns one of the `EventExecutor`s managed by this `EventExecutorGroup`.
`(package private) long`	`nextScheduledTask()`
`EventLoopGroup`	`parent()`	Return the `EventExecutorGroup` which is the parent of this `EventExecutor`,
`ChannelFuture`	`register(Channel channel)`	Register a `Channel` with this `EventLoop`.
`ChannelFuture`	`register(ChannelPromise promise)`	Register a `Channel` with this `EventLoop` using a `ChannelFuture`.
`ChannelFuture`	`register(Channel channel, ChannelPromise promise)`	Deprecated.
`(package private) long`	`runScheduledTasks()`
`(package private) void`	`runTasks()`
`void`	`shutdown()`	Deprecated.
`Future<?>`	`shutdownGracefully(long quietPeriod, long timeout, java.util.concurrent.TimeUnit unit)`	Signals this executor that the caller wants the executor to be shut down.
`Future<?>`	`terminationFuture()`	Returns the `Future` which is notified when all `EventExecutor`s managed by this `EventExecutorGroup` have been terminated.
`Ticker`	`ticker()`	The ticker for this executor.

Methods inherited from class io.netty.util.concurrent.AbstractScheduledEventExecutor
afterScheduledTaskSubmitted, beforeScheduledTaskSubmitted, deadlineToDelayNanos, delayNanos, fetchFromScheduledTaskQueue, hasScheduledTasks, initialNanoTime, nanoTime, nextScheduledTaskDeadlineNanos, nextScheduledTaskNano, pollScheduledTask, pollScheduledTask, schedule, schedule, scheduleAtFixedRate, scheduleWithFixedDelay, validateScheduled

Methods inherited from class io.netty.util.concurrent.AbstractEventExecutor
iterator, lazyExecute, newTaskFor, newTaskFor, runTask, safeExecute, shutdownGracefully, shutdownNow, submit, submit, submit

Methods inherited from class java.util.concurrent.AbstractExecutorService
invokeAll, invokeAll, invokeAny, invokeAny

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface io.netty.util.concurrent.EventExecutor
isExecutorThread, isSuspended, newFailedFuture, newProgressivePromise, newPromise, newSucceededFuture, trySuspend

Methods inherited from interface io.netty.util.concurrent.EventExecutorGroup
iterator, schedule, schedule, scheduleAtFixedRate, scheduleWithFixedDelay, shutdownGracefully, shutdownNow, submit, submit, submit

Methods inherited from interface java.util.concurrent.ExecutorService
invokeAll, invokeAll, invokeAny, invokeAny

Methods inherited from interface java.lang.Iterable
forEach, spliterator

- Field Detail
  - ticker
```
private final Ticker ticker
```
  - tasks
```
private final java.util.Queue<java.lang.Runnable> tasks
```
- Constructor Detail
  - EmbeddedEventLoop
```
EmbeddedEventLoop(Ticker ticker)
```
- Method Detail
  - parent
```
public EventLoopGroup parent()
```
    Description copied from interface: EventExecutor
    
    Return the EventExecutorGroup which is the parent of this EventExecutor,
    
    Specified by:
    
    parent in interface EventExecutor
    
    Specified by:
    
    parent in interface EventLoop
    
    Overrides:
    
    parent in class AbstractEventExecutor
  - next
```
public EventLoop next()
```
    Description copied from interface: EventExecutorGroup
    
    Returns one of the EventExecutors managed by this EventExecutorGroup.
    
    Specified by:
    
    next in interface EventExecutorGroup
    
    Specified by:
    
    next in interface EventLoopGroup
    
    Overrides:
    
    next in class AbstractEventExecutor
  - execute
```
public void execute(java.lang.Runnable command)
```
    Specified by:
    
    execute in interface java.util.concurrent.Executor
  - runTasks
```
void runTasks()
```
  - hasPendingNormalTasks
```
boolean hasPendingNormalTasks()
```
  - runScheduledTasks
```
long runScheduledTasks()
```
  - nextScheduledTask
```
long nextScheduledTask()
```
  - ticker
```
public Ticker ticker()
```
    Description copied from interface: EventExecutorGroup
    
    The ticker for this executor. Usually the EventExecutorGroup.schedule(java.lang.Runnable, long, java.util.concurrent.TimeUnit) methods will follow the system ticker (i.e. System.nanoTime()), but especially for testing it is sometimes useful to have more control over the ticker. In that case, this method will be overridden. Code that schedules tasks on this executor should use this ticker in order to stay consistent with the executor (e.g. not be surprised by scheduled tasks running "early").
    
    Specified by:
    
    ticker in interface EventExecutorGroup
    
    Overrides:
    
    ticker in class AbstractScheduledEventExecutor
    
    Returns:
    
    The ticker for this scheduler
  - getCurrentTimeNanos
```
protected long getCurrentTimeNanos()
```
    Description copied from class: AbstractScheduledEventExecutor
    Get the current time in nanoseconds by this executor's clock. This is not the same as System.nanoTime() for two reasons:
    
    We apply a fixed offset to the nanoTime
    
    Implementations (in particular EmbeddedEventLoop) may use their own time source so they can control time for testing purposes.
    Overrides:
    
    getCurrentTimeNanos in class AbstractScheduledEventExecutor
  - cancelScheduledTasks
```
protected void cancelScheduledTasks()
```
    Description copied from class: AbstractScheduledEventExecutor
    
    Cancel all scheduled tasks. This method MUST be called only when EventExecutor.inEventLoop() is true.
    
    Overrides:
    
    cancelScheduledTasks in class AbstractScheduledEventExecutor
  - shutdownGracefully
```
public Future<?> shutdownGracefully(long quietPeriod,
                                    long timeout,
                                    java.util.concurrent.TimeUnit unit)
```
    Description copied from interface: EventExecutorGroup
    
    Signals this executor that the caller wants the executor to be shut down. Once this method is called, EventExecutorGroup.isShuttingDown() starts to return true, and the executor prepares to shut itself down. Unlike EventExecutorGroup.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.
    
    Specified by:
    
    shutdownGracefully in interface EventExecutorGroup
    
    Parameters:
    
    quietPeriod - the quiet period as described in the documentation
    
    timeout - the maximum amount of time to wait until the executor is EventExecutorGroup.shutdown() regardless if a task was submitted during the quiet period
    
    unit - the unit of quietPeriod and timeout
    
    Returns:
    
    the EventExecutorGroup.terminationFuture()
  - terminationFuture
```
public Future<?> terminationFuture()
```
    Description copied from interface: EventExecutorGroup
    
    Returns the Future which is notified when all EventExecutors managed by this EventExecutorGroup have been terminated.
    
    Specified by:
    
    terminationFuture in interface EventExecutorGroup
  - shutdown
```
@Deprecated
public void shutdown()
```
    Deprecated.
    
    Specified by:
    
    shutdown in interface EventExecutorGroup
    
    Specified by:
    
    shutdown in interface java.util.concurrent.ExecutorService
    
    Specified by:
    
    shutdown in class AbstractEventExecutor
  - isShuttingDown
```
public boolean isShuttingDown()
```
    Description copied from interface: EventExecutorGroup
    
    Returns true if and only if all EventExecutors managed by this EventExecutorGroup are being shut down gracefully or was shut down.
    
    Specified by:
    
    isShuttingDown in interface EventExecutorGroup
  - isShutdown
```
public boolean isShutdown()
```
    Specified by:
    
    isShutdown in interface java.util.concurrent.ExecutorService
  - isTerminated
```
public boolean isTerminated()
```
    Specified by:
    
    isTerminated in interface java.util.concurrent.ExecutorService
  - awaitTermination
```
public boolean awaitTermination(long timeout,
                                java.util.concurrent.TimeUnit unit)
```
    Specified by:
    
    awaitTermination in interface java.util.concurrent.ExecutorService
  - register
```
public ChannelFuture register(Channel channel)
```
    Description copied from interface: EventLoopGroup
    
    Register a Channel with this EventLoop. The returned ChannelFuture will get notified once the registration was complete.
    
    Specified by:
    
    register in interface EventLoopGroup
  - register
```
public ChannelFuture register(ChannelPromise promise)
```
    Description copied from interface: EventLoopGroup
    
    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.
    
    Specified by:
    
    register in interface EventLoopGroup
  - register
```
@Deprecated
public ChannelFuture register(Channel channel,
                              ChannelPromise promise)
```
    Deprecated.
    
    Description copied from interface: EventLoopGroup
    
    Register a Channel with this EventLoop. The passed ChannelFuture will get notified once the registration was complete and also will get returned.
    
    Specified by:
    
    register in interface EventLoopGroup
  - inEventLoop
```
public boolean inEventLoop()
```
    Description copied from interface: EventExecutor
    
    Calls EventExecutor.inEventLoop(Thread) with Thread.currentThread() as argument
    
    Specified by:
    
    inEventLoop in interface EventExecutor
  - inEventLoop
```
public boolean inEventLoop(java.lang.Thread thread)
```
    Description copied from interface: EventExecutor
    
    Return true if the given Thread is executed in the event loop, false otherwise.
    
    Specified by:
    
    inEventLoop in interface EventExecutor

Modifier and Type	Field	Description
`private java.util.Queue<java.lang.Runnable>`	`tasks`
`private Ticker`	`ticker`

Class EmbeddedEventLoop

Nested Class Summary

Nested classes/interfaces inherited from class io.netty.util.concurrent.AbstractEventExecutor

Field Summary

Constructor Summary

Method Summary

Methods inherited from class io.netty.util.concurrent.AbstractScheduledEventExecutor

Methods inherited from class io.netty.util.concurrent.AbstractEventExecutor

Methods inherited from class java.util.concurrent.AbstractExecutorService

Methods inherited from class java.lang.Object

Methods inherited from interface io.netty.util.concurrent.EventExecutor

Methods inherited from interface io.netty.util.concurrent.EventExecutorGroup

Methods inherited from interface java.util.concurrent.ExecutorService

Methods inherited from interface java.lang.Iterable

Field Detail

ticker

tasks

Constructor Detail

EmbeddedEventLoop

Method Detail

parent

next

execute

runTasks

hasPendingNormalTasks

runScheduledTasks

nextScheduledTask

ticker

getCurrentTimeNanos

cancelScheduledTasks

shutdownGracefully

terminationFuture

shutdown

isShuttingDown

isShutdown

isTerminated

awaitTermination

register

register

register

inEventLoop

inEventLoop