HashedWheelTimer

java.lang.Object
- org.jboss.netty.util.HashedWheelTimer

All Implemented Interfaces:

Timer
```
public class HashedWheelTimer
extends java.lang.Object
implements Timer
```
A Timer optimized for approximated I/O timeout scheduling.
Tick Duration
As described with 'approximated', this timer does not execute the scheduled TimerTask on time. HashedWheelTimer, on every tick, will check if there are any TimerTasks behind the schedule and execute them.
You can increase or decrease the accuracy of the execution timing by specifying smaller or larger tick duration in the constructor. In most network applications, I/O timeout does not need to be accurate. Therefore, the default tick duration is 100 milliseconds and you will not need to try different configurations in most cases.
Ticks per Wheel (Wheel Size)
HashedWheelTimer maintains a data structure called 'wheel'. To put simply, a wheel is a hash table of TimerTasks whose hash function is 'dead line of the task'. The default number of ticks per wheel (i.e. the size of the wheel) is 512. You could specify a larger value if you are going to schedule a lot of timeouts.
Do not create many instances.
HashedWheelTimer creates a new thread whenever it is instantiated and started. Therefore, you should make sure to create only one instance and share it across your application. One of the common mistakes, that makes your application unresponsive, is to create a new instance in ChannelPipelineFactory, which results in the creation of a new thread for every connection.
Implementation Details
HashedWheelTimer is based on George Varghese and Tony Lauck's paper, 'Hashed and Hierarchical Timing Wheels: data structures to efficiently implement a timer facility'. More comprehensive slides are located here.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`private static class`	`HashedWheelTimer.HashedWheelBucket` Bucket that stores HashedWheelTimeouts.
`private static class`	`HashedWheelTimer.HashedWheelTimeout`
`private class`	`HashedWheelTimer.Worker`

Field Summary

Fields
Modifier and Type	Field and Description
`private static java.util.concurrent.atomic.AtomicInteger`	`id`
`(package private) static InternalLogger`	`logger`
`private int`	`mask`
`private static SharedResourceMisuseDetector`	`misuseDetector`
`private long`	`startTime`
`private java.util.concurrent.CountDownLatch`	`startTimeInitialized`
`private long`	`tickDuration`
`private java.util.Queue<HashedWheelTimer.HashedWheelTimeout>`	`timeouts`
`private HashedWheelTimer.HashedWheelBucket[]`	`wheel`
`private HashedWheelTimer.Worker`	`worker`
`static int`	`WORKER_STATE_INIT`
`static int`	`WORKER_STATE_SHUTDOWN`
`static int`	`WORKER_STATE_STARTED`
`private static java.util.concurrent.atomic.AtomicIntegerFieldUpdater<HashedWheelTimer>`	`WORKER_STATE_UPDATER`
`private int`	`workerState`
`private java.lang.Thread`	`workerThread`

Constructor Summary

Constructors
Constructor and Description
`HashedWheelTimer()` Creates a new timer with the default thread factory (`Executors.defaultThreadFactory()`), default tick duration, and default number of ticks per wheel.
`HashedWheelTimer(long tickDuration, java.util.concurrent.TimeUnit unit)` Creates a new timer with the default thread factory (`Executors.defaultThreadFactory()`) and default number of ticks per wheel.
`HashedWheelTimer(long tickDuration, java.util.concurrent.TimeUnit unit, int ticksPerWheel)` Creates a new timer with the default thread factory (`Executors.defaultThreadFactory()`).
`HashedWheelTimer(java.util.concurrent.ThreadFactory threadFactory)` Creates a new timer with the default tick duration and default number of ticks per wheel.
`HashedWheelTimer(java.util.concurrent.ThreadFactory threadFactory, long tickDuration, java.util.concurrent.TimeUnit unit)` Creates a new timer with the default number of ticks per wheel.
`HashedWheelTimer(java.util.concurrent.ThreadFactory threadFactory, long tickDuration, java.util.concurrent.TimeUnit unit, int ticksPerWheel)` Creates a new timer.
`HashedWheelTimer(java.util.concurrent.ThreadFactory threadFactory, ThreadNameDeterminer determiner, long tickDuration, java.util.concurrent.TimeUnit unit, int ticksPerWheel)` Creates a new timer.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`private static HashedWheelTimer.HashedWheelBucket[]`	`createWheel(int ticksPerWheel)`
`Timeout`	`newTimeout(TimerTask task, long delay, java.util.concurrent.TimeUnit unit)` Schedules the specified `TimerTask` for one-time execution after the specified delay.
`private static int`	`normalizeTicksPerWheel(int ticksPerWheel)`
`void`	`start()` Starts the background thread explicitly.
`java.util.Set<Timeout>`	`stop()` Releases all resources acquired by this `Timer` and cancels all tasks which were scheduled but not executed yet.

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

- Field Detail
  - logger
```
static final InternalLogger logger
```
  - id
```
private static final java.util.concurrent.atomic.AtomicInteger id
```
  - misuseDetector
```
private static final SharedResourceMisuseDetector misuseDetector
```
  - WORKER_STATE_UPDATER
```
private static final java.util.concurrent.atomic.AtomicIntegerFieldUpdater<HashedWheelTimer> WORKER_STATE_UPDATER
```
  - worker
```
private final HashedWheelTimer.Worker worker
```
  - workerThread
```
private final java.lang.Thread workerThread
```
  - WORKER_STATE_INIT
```
public static final int WORKER_STATE_INIT
```
    See Also:
    
    Constant Field Values
  - WORKER_STATE_STARTED
```
public static final int WORKER_STATE_STARTED
```
    See Also:
    
    Constant Field Values
  - WORKER_STATE_SHUTDOWN
```
public static final int WORKER_STATE_SHUTDOWN
```
    See Also:
    
    Constant Field Values
  - workerState
```
private volatile int workerState
```
  - tickDuration
```
private final long tickDuration
```
  - wheel
```
private final HashedWheelTimer.HashedWheelBucket[] wheel
```
  - mask
```
private final int mask
```
  - startTimeInitialized
```
private final java.util.concurrent.CountDownLatch startTimeInitialized
```
  - timeouts
```
private final java.util.Queue<HashedWheelTimer.HashedWheelTimeout> timeouts
```
  - startTime
```
private volatile long startTime
```
- Constructor Detail
  - HashedWheelTimer
```
public HashedWheelTimer()
```
    Creates a new timer with the default thread factory (Executors.defaultThreadFactory()), default tick duration, and default number of ticks per wheel.
  - HashedWheelTimer
```
public HashedWheelTimer(long tickDuration,
                        java.util.concurrent.TimeUnit unit)
```
    Creates a new timer with the default thread factory (Executors.defaultThreadFactory()) and default number of ticks per wheel.
    
    Parameters:
    
    tickDuration - the duration between tick
    
    unit - the time unit of the tickDuration
  - HashedWheelTimer
```
public HashedWheelTimer(long tickDuration,
                        java.util.concurrent.TimeUnit unit,
                        int ticksPerWheel)
```
    Creates a new timer with the default thread factory (Executors.defaultThreadFactory()).
    
    Parameters:
    
    tickDuration - the duration between tick
    
    unit - the time unit of the tickDuration
    
    ticksPerWheel - the size of the wheel
  - HashedWheelTimer
```
public HashedWheelTimer(java.util.concurrent.ThreadFactory threadFactory)
```
    Creates a new timer with the default tick duration and default number of ticks per wheel.
    
    Parameters:
    
    threadFactory - a ThreadFactory that creates a background Thread which is dedicated to TimerTask execution.
  - HashedWheelTimer
```
public HashedWheelTimer(java.util.concurrent.ThreadFactory threadFactory,
                        long tickDuration,
                        java.util.concurrent.TimeUnit unit)
```
    Creates a new timer with the default number of ticks per wheel.
    
    Parameters:
    
    threadFactory - a ThreadFactory that creates a background Thread which is dedicated to TimerTask execution.
    
    tickDuration - the duration between tick
    
    unit - the time unit of the tickDuration
  - HashedWheelTimer
```
public HashedWheelTimer(java.util.concurrent.ThreadFactory threadFactory,
                        long tickDuration,
                        java.util.concurrent.TimeUnit unit,
                        int ticksPerWheel)
```
    Creates a new timer.
    
    Parameters:
    
    threadFactory - a ThreadFactory that creates a background Thread which is dedicated to TimerTask execution.
    
    tickDuration - the duration between tick
    
    unit - the time unit of the tickDuration
    
    ticksPerWheel - the size of the wheel
  - HashedWheelTimer
```
public HashedWheelTimer(java.util.concurrent.ThreadFactory threadFactory,
                        ThreadNameDeterminer determiner,
                        long tickDuration,
                        java.util.concurrent.TimeUnit unit,
                        int ticksPerWheel)
```
    Creates a new timer.
    
    Parameters:
    
    threadFactory - a ThreadFactory that creates a background Thread which is dedicated to TimerTask execution.
    
    determiner - thread name determiner to control thread name.
    
    tickDuration - the duration between tick
    
    unit - the time unit of the tickDuration
    
    ticksPerWheel - the size of the wheel
- Method Detail
  - createWheel
```
private static HashedWheelTimer.HashedWheelBucket[] createWheel(int ticksPerWheel)
```
  - normalizeTicksPerWheel
```
private static int normalizeTicksPerWheel(int ticksPerWheel)
```
  - start
```
public void start()
```
    Starts the background thread explicitly. The background thread will start automatically on demand even if you did not call this method.
    
    Throws:
    
    java.lang.IllegalStateException - if this timer has been stopped already
  - stop
```
public java.util.Set<Timeout> stop()
```
    Description copied from interface: Timer
    
    Releases all resources acquired by this Timer and cancels all tasks which were scheduled but not executed yet.
    
    Specified by:
    
    stop in interface Timer
    
    Returns:
    
    the handles associated with the tasks which were canceled by this method
  - newTimeout
```
public Timeout newTimeout(TimerTask task,
                          long delay,
                          java.util.concurrent.TimeUnit unit)
```
    Description copied from interface: Timer
    
    Schedules the specified TimerTask for one-time execution after the specified delay.
    
    Specified by:
    
    newTimeout in interface Timer
    
    Returns:
    
    a handle which is associated with the specified task

Class HashedWheelTimer

Tick Duration

Ticks per Wheel (Wheel Size)

Do not create many instances.

Implementation Details

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

logger

id

misuseDetector

WORKER_STATE_UPDATER

worker

workerThread

WORKER_STATE_INIT

WORKER_STATE_STARTED

WORKER_STATE_SHUTDOWN

workerState

tickDuration

wheel

mask

startTimeInitialized

timeouts

startTime

Constructor Detail

HashedWheelTimer

HashedWheelTimer

HashedWheelTimer

HashedWheelTimer

HashedWheelTimer

HashedWheelTimer

HashedWheelTimer

Method Detail

createWheel

normalizeTicksPerWheel

start

stop

newTimeout