jhelp.util.thread

Class ThreadManager

java.lang.Object

jhelp.util.thread.ThreadManager

public final class ThreadManager
extends java.lang.Object

Thread manager.
It manage a number of maximum thread in same time, it recycles threads that have finished there task to do next task.
It is better than created a new Thread because here the number of thread is control.
If a task as to do now and no thread is free, the task wait for the first free thread with high priority.
It is possible to launch on other task inside a task, that is not a good idea in classical schedulling system (Here no interblocking).
To use implements ThreadedTask, ThreadedSimpleTask or ThreadedVerySimpleTask, then you can do the task as soon as possible with doThread(ThreadedTask, Object), do action in delayed future with delayedThread(ThreadedTask, Object, long) or repeat the task with repeatThread(ThreadedTask, Object, long, long)

Author:

JHelp

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
(package private) class	ThreadManager.DoManagement Dedicated thread for do the management

Field Summary

Fields

Modifier and Type	Field and Description
private boolean	alive Indicates if the manager is alive
private ThreadManager.DoManagement	doManagement Do the management
private boolean	haveToActAsSoonAsPossible Indicates if their at least a task that wait urgently for a free thread
(package private) static java.lang.Object	LOCK For synchronize the waiting task and the running threads
(package private) static int	MAXIMUM_WAIT Maximum time to wait a new free thread/task to do , before check.
(package private) static int	MINIMUM_REPEAT Minimum time between repeat (Never put under 1)
(package private) static int	MINIMUM_WAIT Minimum time before do an action (The meaning of "as soon as possible") (never put under 1)
private static int	NUMBER_OF_ACTIVE_THREAD Number of maximum thread running in same time (If you change this number, I advice to not go under 8, and if you choose a high value, you may notice a slow or out of memory.
(package private) java.util.PriorityQueue<ThreadElement<?,?,?>>	priorityQueue Task to do waiting queue
static ThreadManager	THREAD_MANAGER Thread manager unique singleton instance
private ThreadedSimpleTask<java.lang.Integer>	threadCancelTask Delayed cancel task
(package private) ThreadActor[]	threads Threads that does the tasks
private int	waitCount Count the number of waiting process

Constructor Summary

Constructors

Modifier	Constructor and Description
private	ThreadManager() Create a new instance of ThreadManager

Method Summary

Methods

Modifier and Type	Method and Description
(package private) void	anActorIsFree() Call by a thread to say he is free, so ready for do next task
int	approximativeNumberOfFreeThread() Give the approximative value of number of free thread.
void	cancelTask(int id) Cancel a task.
<PARAMETER,RESULT,PROGRESS> void	delayedThread(ThreadedTask<PARAMETER,RESULT,PROGRESS> threadedTask, PARAMETER parameter, long delay) Do a task in a delayed time.
void	destroy() Destroy properly the manager.
<PARAMETER,RESULT,PROGRESS> void	doThread(ThreadedTask<PARAMETER,RESULT,PROGRESS> threadedTask, PARAMETER parameter) Do a task as soon as possible.
(package private) void	internalAdd(ThreadElement<?,?,?> threadElement) Adding a task internally.
boolean	nearFull() Indicates if thread manager is near full.
<PARAMETER,RESULT,PROGRESS> int	repeatThread(ThreadedTask<PARAMETER,RESULT,PROGRESS> threadedTask, PARAMETER parameter, long delay, long repeat) Repeat a task
void	restart() Restart the thread manager
(package private) void	runDoManagement() Do the management

Methods inherited from class java.lang.Object

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

Field Detail

NUMBER_OF_ACTIVE_THREAD

private static final int NUMBER_OF_ACTIVE_THREAD

Number of maximum thread running in same time (If you change this number, I advice to not go under 8, and if you choose a high value, you may notice a slow or out of memory. For now 128 is a good compromise for what I tested

See Also:

Constant Field Values

LOCK

static final java.lang.Object LOCK

For synchronize the waiting task and the running threads

MAXIMUM_WAIT

static final int MAXIMUM_WAIT

Maximum time to wait a new free thread/task to do , before check. No block infinity (with 0) because can may some bad effects (block). We choose a enought long time to not "agress" the CPU, but enough short to have an escape on bad situation that may happen (never meet for now)

See Also:

Constant Field Values

MINIMUM_REPEAT

static final int MINIMUM_REPEAT

Minimum time between repeat (Never put under 1)

See Also:

Constant Field Values

MINIMUM_WAIT

static final int MINIMUM_WAIT

Minimum time before do an action (The meaning of "as soon as possible") (never put under 1)

See Also:

Constant Field Values

THREAD_MANAGER

public static final ThreadManager THREAD_MANAGER

Thread manager unique singleton instance

alive

private boolean alive

Indicates if the manager is alive

doManagement

private final ThreadManager.DoManagement doManagement

Do the management

haveToActAsSoonAsPossible

private boolean haveToActAsSoonAsPossible

Indicates if their at least a task that wait urgently for a free thread

threadCancelTask

private final ThreadedSimpleTask<java.lang.Integer> threadCancelTask

Delayed cancel task

waitCount

private int waitCount

Count the number of waiting process

priorityQueue

final java.util.PriorityQueue<ThreadElement<?,?,?>> priorityQueue

Task to do waiting queue

threads

final ThreadActor[] threads

Threads that does the tasks

Constructor Detail

ThreadManager

private ThreadManager()

Create a new instance of ThreadManager

Method Detail

anActorIsFree

void anActorIsFree()

Call by a thread to say he is free, so ready for do next task

internalAdd

void internalAdd(ThreadElement<?,?,?> threadElement)

Adding a task internally.
Use by repeat system

Parameters:

threadElement - Thread to add

runDoManagement

void runDoManagement()

Do the management

approximativeNumberOfFreeThread

public int approximativeNumberOfFreeThread()

Give the approximative value of number of free thread.
Because threads are free, and taken at any time, the value can't be accurate, its just an idea of the result

Returns:

Approximative value of number of free thread

cancelTask

public void cancelTask(int id)

Cancel a task.
The cancel is not immediate, it is do as soon as possible

Parameters:

id - Task id to cancel, give by repeatThread(ThreadedTask, Object, long, long)

delayedThread

public <PARAMETER,RESULT,PROGRESS> void delayedThread(ThreadedTask<PARAMETER,RESULT,PROGRESS> threadedTask,
                                             PARAMETER parameter,
                                             long delay)

Do a task in a delayed time.
When task turn comes, the given parameter is given to it, so you can can this method several times with the same instance of task, but different parameter.

Type Parameters:

PARAMETER - Parameter type

RESULT - Result type of the task

PROGRESS - Progression information type of the task

Parameters:

threadedTask - Task to do

parameter - Parameter to give to the task, when its turn comes

delay - Number of milliseconds to wait before do the task

destroy

public void destroy()

Destroy properly the manager.
Don't use it after call the method

doThread

public <PARAMETER,RESULT,PROGRESS> void doThread(ThreadedTask<PARAMETER,RESULT,PROGRESS> threadedTask,
                                        PARAMETER parameter)

Do a task as soon as possible.

Type Parameters:

PARAMETER - Parameter tpye

RESULT - Result type

PROGRESS - Progression type

Parameters:

threadedTask - Task to do

parameter - Parameter gives to the task when its turn comes

nearFull

public boolean nearFull()

Indicates if thread manager is near full.
Like approximativeNumberOfFreeThread() it can't be total accurate, but it give a good idea

Returns:

true if thread manager is near full

repeatThread

public <PARAMETER,RESULT,PROGRESS> int repeatThread(ThreadedTask<PARAMETER,RESULT,PROGRESS> threadedTask,
                                           PARAMETER parameter,
                                           long delay,
                                           long repeat)

Repeat a task

Type Parameters:

PARAMETER - Parameter type

RESULT - Result type

PROGRESS - Progress type

Parameters:

threadedTask - Task to repeat

parameter - Parameter give to the task at each repeat

delay - Time to wait in millisecond before do the first time

repeat - Time between each repeat in milliseconds

Returns:

Task ID to able cancel it later with cancelTask(int)

restart

public void restart()

Restart the thread manager