Package org.jboss.netty.handler.execution

Class FairOrderedMemoryAwareThreadPoolExecutor

java.lang.Object

java.util.concurrent.AbstractExecutorService

java.util.concurrent.ThreadPoolExecutor

org.jboss.netty.handler.execution.MemoryAwareThreadPoolExecutor

org.jboss.netty.handler.execution.FairOrderedMemoryAwareThreadPoolExecutor

All Implemented Interfaces:

Executor, ExecutorService

Direct Known Subclasses:

FairOrderedDownstreamThreadPoolExecutor

public class FairOrderedMemoryAwareThreadPoolExecutor
extends MemoryAwareThreadPoolExecutor

This is a fair alternative of OrderedMemoryAwareThreadPoolExecutor .

Unfair of OrderedMemoryAwareThreadPoolExecutor

The task executed in OrderedMemoryAwareThreadPoolExecutor is unfair in some situations. For example, let's say there is only one executor thread that handle the events from the two channels, and events are submitted in sequence:

           Channel A (Event A1) , Channel B (Event B), Channel A (Event A2) , ... , Channel A (Event An)
 

Then the events maybe executed in this unfair order:

          ----------------------------------------> Timeline -------------------------------->
           Channel A (Event A1) , Channel A (Event A2) , ... , Channel A (Event An), Channel B (Event B)
 

As we see above, Channel B (Event B) maybe executed unfairly late. Even more, if there are too much events come in Channel A, and one-by-one closely, then Channel B (Event B) would be waiting for a long while and become "hungry".

Fair of FairOrderedMemoryAwareThreadPoolExecutor

In the same case above ( one executor thread and two channels ) , this implement will guarantee execution order as:

          ----------------------------------------> Timeline -------------------------------->
           Channel A (Event A1) , Channel B (Event B), Channel A (Event A2) , ... , Channel A (Event An),
 

NOTE: For convenience the case above use one single executor thread, but the fair mechanism is suitable for multiple executor threads situations.

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
protected final class	FairOrderedMemoryAwareThreadPoolExecutor.EventTask

Nested classes/interfaces inherited from class java.util.concurrent.ThreadPoolExecutor

ThreadPoolExecutor.AbortPolicy, ThreadPoolExecutor.CallerRunsPolicy, ThreadPoolExecutor.DiscardOldestPolicy, ThreadPoolExecutor.DiscardPolicy

Field Summary

Fields

Modifier and Type	Field	Description
private final FairOrderedMemoryAwareThreadPoolExecutor.EventTask	end
private final AtomicReferenceFieldUpdater<FairOrderedMemoryAwareThreadPoolExecutor.EventTask,FairOrderedMemoryAwareThreadPoolExecutor.EventTask>	fieldUpdater
protected final ConcurrentMap<Object,FairOrderedMemoryAwareThreadPoolExecutor.EventTask>	map

Constructor Summary

Constructors

Constructor	Description
FairOrderedMemoryAwareThreadPoolExecutor(int corePoolSize, long maxChannelMemorySize, long maxTotalMemorySize)	Creates a new instance.
FairOrderedMemoryAwareThreadPoolExecutor(int corePoolSize, long maxChannelMemorySize, long maxTotalMemorySize, long keepAliveTime, TimeUnit unit)	Creates a new instance.
FairOrderedMemoryAwareThreadPoolExecutor(int corePoolSize, long maxChannelMemorySize, long maxTotalMemorySize, long keepAliveTime, TimeUnit unit, ThreadFactory threadFactory)	Creates a new instance.
FairOrderedMemoryAwareThreadPoolExecutor(int corePoolSize, long maxChannelMemorySize, long maxTotalMemorySize, long keepAliveTime, TimeUnit unit, ObjectSizeEstimator objectSizeEstimator, ThreadFactory threadFactory)	Creates a new instance.

Method Summary

Modifier and Type	Method	Description
protected final boolean	compareAndSetNext(FairOrderedMemoryAwareThreadPoolExecutor.EventTask eventTask, FairOrderedMemoryAwareThreadPoolExecutor.EventTask expect, FairOrderedMemoryAwareThreadPoolExecutor.EventTask update)
protected void	doExecute(Runnable task)	Executes the specified task concurrently while maintaining the event order.
protected Object	getKey(ChannelEvent e)
protected ConcurrentMap<Object,FairOrderedMemoryAwareThreadPoolExecutor.EventTask>	newMap()
private void	removeIfClosed(ChannelEventRunnable eventRunnable, Object key)
protected boolean	removeKey(Object key)	call removeKey(Object key) when the life cycle of the key ends, such as when the channel is closed
protected boolean	shouldCount(Runnable task)	Returns true if and only if the specified task should be counted to limit the global and per-channel memory consumption.

Methods inherited from class org.jboss.netty.handler.execution.MemoryAwareThreadPoolExecutor

beforeExecute, decreaseCounter, doUnorderedExecute, execute, getMaxChannelMemorySize, getMaxTotalMemorySize, getNotifyChannelFuturesOnShutdown, getObjectSizeEstimator, increaseCounter, remove, setMaxChannelMemorySize, setNotifyChannelFuturesOnShutdown, setObjectSizeEstimator, shutdownNow, shutdownNow, terminated

Methods inherited from class java.util.concurrent.ThreadPoolExecutor

afterExecute, allowCoreThreadTimeOut, allowsCoreThreadTimeOut, awaitTermination, finalize, getActiveCount, getCompletedTaskCount, getCorePoolSize, getKeepAliveTime, getLargestPoolSize, getMaximumPoolSize, getPoolSize, getQueue, getRejectedExecutionHandler, getTaskCount, getThreadFactory, isShutdown, isTerminated, isTerminating, prestartAllCoreThreads, prestartCoreThread, purge, setCorePoolSize, setKeepAliveTime, setMaximumPoolSize, setRejectedExecutionHandler, setThreadFactory, shutdown, toString

Methods inherited from class java.util.concurrent.AbstractExecutorService

invokeAll, invokeAll, invokeAny, invokeAny, newTaskFor, newTaskFor, submit, submit, submit

Methods inherited from class java.lang.Object

clone, equals, getClass, hashCode, notify, notifyAll, wait, wait, wait

Field Details

end

private final FairOrderedMemoryAwareThreadPoolExecutor.EventTask end

fieldUpdater

private final AtomicReferenceFieldUpdater<FairOrderedMemoryAwareThreadPoolExecutor.EventTask,FairOrderedMemoryAwareThreadPoolExecutor.EventTask> fieldUpdater

map

protected final ConcurrentMap<Object,FairOrderedMemoryAwareThreadPoolExecutor.EventTask> map

Constructor Details

FairOrderedMemoryAwareThreadPoolExecutor

public FairOrderedMemoryAwareThreadPoolExecutor(int corePoolSize,
 long maxChannelMemorySize,
 long maxTotalMemorySize)

Creates a new instance.

Parameters:

corePoolSize - the maximum number of active threads

maxChannelMemorySize - the maximum total size of the queued events per channel. Specify 0 to disable.

maxTotalMemorySize - the maximum total size of the queued events for this pool Specify 0 to disable.

FairOrderedMemoryAwareThreadPoolExecutor

public FairOrderedMemoryAwareThreadPoolExecutor(int corePoolSize,
 long maxChannelMemorySize,
 long maxTotalMemorySize,
 long keepAliveTime,
 TimeUnit unit)

Creates a new instance.

Parameters:

corePoolSize - the maximum number of active threads

maxChannelMemorySize - the maximum total size of the queued events per channel. Specify 0 to disable.

maxTotalMemorySize - the maximum total size of the queued events for this pool Specify 0 to disable.

keepAliveTime - the amount of time for an inactive thread to shut itself down

unit - the TimeUnit of keepAliveTime

FairOrderedMemoryAwareThreadPoolExecutor

public FairOrderedMemoryAwareThreadPoolExecutor(int corePoolSize,
 long maxChannelMemorySize,
 long maxTotalMemorySize,
 long keepAliveTime,
 TimeUnit unit,
 ThreadFactory threadFactory)

Creates a new instance.

Parameters:

corePoolSize - the maximum number of active threads

maxChannelMemorySize - the maximum total size of the queued events per channel. Specify 0 to disable.

maxTotalMemorySize - the maximum total size of the queued events for this pool Specify 0 to disable.

keepAliveTime - the amount of time for an inactive thread to shut itself down

unit - the TimeUnit of keepAliveTime

threadFactory - the ThreadFactory of this pool

FairOrderedMemoryAwareThreadPoolExecutor

public FairOrderedMemoryAwareThreadPoolExecutor(int corePoolSize,
 long maxChannelMemorySize,
 long maxTotalMemorySize,
 long keepAliveTime,
 TimeUnit unit,
 ObjectSizeEstimator objectSizeEstimator,
 ThreadFactory threadFactory)

Creates a new instance.

Parameters:

corePoolSize - the maximum number of active threads

maxChannelMemorySize - the maximum total size of the queued events per channel. Specify 0 to disable.

maxTotalMemorySize - the maximum total size of the queued events for this pool Specify 0 to disable.

keepAliveTime - the amount of time for an inactive thread to shut itself down

unit - the TimeUnit of keepAliveTime

objectSizeEstimator - the ObjectSizeEstimator of this pool

threadFactory - the ThreadFactory of this pool

Method Details

newMap

protected ConcurrentMap<Object,FairOrderedMemoryAwareThreadPoolExecutor.EventTask> newMap()

doExecute

protected void doExecute(Runnable task)

Executes the specified task concurrently while maintaining the event order.

Overrides:

doExecute in class MemoryAwareThreadPoolExecutor

removeIfClosed

private void removeIfClosed(ChannelEventRunnable eventRunnable,
 Object key)

removeKey

protected boolean removeKey(Object key)

call removeKey(Object key) when the life cycle of the key ends, such as when the channel is closed

getKey

protected Object getKey(ChannelEvent e)

shouldCount

protected boolean shouldCount(Runnable task)

Description copied from class: MemoryAwareThreadPoolExecutor

Returns true if and only if the specified task should be counted to limit the global and per-channel memory consumption. To override this method, you must call super.shouldCount() to make sure important tasks are not counted.

Overrides:

shouldCount in class MemoryAwareThreadPoolExecutor

compareAndSetNext

protected final boolean compareAndSetNext(FairOrderedMemoryAwareThreadPoolExecutor.EventTask eventTask,
 FairOrderedMemoryAwareThreadPoolExecutor.EventTask expect,
 FairOrderedMemoryAwareThreadPoolExecutor.EventTask update)