com.kamontat.utilities

Class ExecuteWorker

java.lang.Object

com.kamontat.utilities.ExecuteWorker

public class ExecuteWorker
extends Object

Execute some very very slow code in some way, that make java code much more Asynchronous programming
Meaning: if you want to run some code in background or want to wait until the code been finished.
In this class I use ExecutorService to manage the task, I create 3 type of execution

1. Schedule - to schedule execute action with delay until some ime
2. execute(Callable) - To do some task in the background
3. executeAndWaitAll(Runnable...) or executeAndWaitAny(Callable[]) - Exxecute some very task and want program to wait until the task was end

Beware: To use the multiThread class, after you don't use the class anymore please call shutdown() or forceShutdown() to stop and terminal the thread

Example:

     // create new thread
     ExecuteWorker thread = new ExecuteWorker(Executors.newScheduledThreadPool(1));
     // print "Hello world!" in every 1 second for 1 minutes
     thread.schedule(() -> System.out.println("Hello world!"), 0, 1, 60, TimeUnit.SECONDS);
     // close the thread
     multiThread.shutdown();
 

Since:

Wed 15/Mar/2017 - 10:08 PM

Version:

1.0

Author:

kamontat

See Also:

ExecutorService, Executors, Future

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
class	ExecuteWorker.ScheduleFutureImp This class implemented because I need the easy way to manage the ScheduledFuture This class have new method call ExecuteWorker.ScheduleFutureImp.waitAndDone() so that program will wait until program done

Constructor Summary

Constructors

Constructor and Description
ExecuteWorker(ExecutorService service) create multi-thread service.

Method Summary

Modifier and Type	Method and Description
static void	doBackground(Runnable run) do run on background using SwingWorker
static void	doBackground(Runnable run, Runnable done) do run on background using SwingWorker
<T> Future<T>	execute(Callable<T> callable) To execute method Runnable.run() in the background
Future<?>	execute(Runnable runnable) To execute method Runnable.run() in the background
<T> List<Future<T>>	executeAndWaitAll(Callable<T>... callable) execute the tasks and wait until all task was successfully
List<Future<?>>	executeAndWaitAll(Runnable... runnable) convert to Callable and run executeAndWaitAll(Callable[])
<T> T	executeAndWaitAny(Callable<T>... callable) execute the tasks and wait until some of task was successfully (require only one task and method will done)
void	executeAndWaitAny(Runnable... runnable) convert to Callable and run executeAndWaitAny(Callable[])
List<Runnable>	forceShutdown() force shutdown and return the task that not execute successfully.
boolean	isShutDown() to check is this class already shutdown
boolean	isTerminate() Inherit docs from ExecutorService.isTerminated() Returns true if all tasks have completed following shut down.
ExecuteWorker.ScheduleFutureImp	schedule(Runnable runnable, int initial, int delay, int until, TimeUnit unit, boolean fix) The service must be ScheduledExecutorService class the scheduling the task in time interval at the future,
void	shutdown() if create this class, you must shutdown it at last
static <T> Callable<T>	toCall(Runnable runnable, T returnValue) convert runnable to callable with return value is parameter returnValue
static Runnable	toRun(Callable<?> callable) convert callable to runnable with ignore all exception and return value.
boolean	wait(long time, TimeUnit unit) Blocks until all tasks have completed.

Methods inherited from class java.lang.Object

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

Constructor Detail

ExecuteWorker

public ExecuteWorker(ExecutorService service)

create multi-thread service.
the parameter, can pass by Executors factory

Parameters:

service - the running service

Method Detail

schedule

public ExecuteWorker.ScheduleFutureImp schedule(Runnable runnable,
                                                int initial,
                                                int delay,
                                                int until,
                                                TimeUnit unit,
                                                boolean fix)

The service must be ScheduledExecutorService class
the scheduling the task in time interval at the future,

And because of ScheduledExecutorService don't have method that can rerun the task and end at some time so I need to implement by myself by using Future.cancel(boolean) method to cancel it when task should be end.
Example:

Parameters:

runnable - method that want to execute

initial - the time interval at first run runnable

delay - the time interval

until - the time end

unit - unit if the time

fix - true when the delay time meaning delay time will fixed (not whether execute time is what but program will add more delay time on it); otherwise is false

1. if true you can learn more at ScheduledExecutorService.scheduleWithFixedDelay(Runnable, long, long, TimeUnit)
2. if false you can learn more at ScheduledExecutorService.scheduleAtFixedRate(Runnable, long, long, TimeUnit)

Returns:

ScheduledFuture - this class will let you know what going on, since this method will close from cancellation only so you cannot use the method get() normally

execute

public Future<?> execute(Runnable runnable)
                  throws RejectedExecutionException

To execute method Runnable.run() in the background

Parameters:

runnable - run task

Returns:

the object that represent future result, if you call Future.get() when task execute successfully, it's wil return null

Throws:

RejectedExecutionException - if the task cannot be scheduled for execution

NullPointerException - if runnable is null

See Also:

Future

execute

public <T> Future<T> execute(Callable<T> callable)
                      throws RejectedExecutionException

To execute method Runnable.run() in the background

Type Parameters:

T - the return object value

Parameters:

callable - the run task

Returns:

the object that represent future result, if you call Future.get() when task execute successfully, it's wil return object T

Throws:

RejectedExecutionException - if the task cannot be scheduled for execution

NullPointerException - if runnable is null

See Also:

Future

executeAndWaitAll

@SafeVarargs
public final <T> List<Future<T>> executeAndWaitAll(Callable<T>... callable)
                                                         throws RejectedExecutionException

execute the tasks and wait until all task was successfully

Type Parameters:

T - the return type

Parameters:

callable - the run task

Returns:

list of all task that represent the task that has been executed, or
Null if there have InterruptedException cause

Throws:

RejectedExecutionException - if the task cannot be scheduled for execution

NullPointerException - if runnable is null

See Also:

Future

executeAndWaitAny

@SafeVarargs
public final <T> T executeAndWaitAny(Callable<T>... callable)
                                           throws RejectedExecutionException

execute the tasks and wait until some of task was successfully (require only one task and method will done)

Type Parameters:

T - the return type

Parameters:

callable - the run task

Returns:

The resulting of the execute task that finish at first, or
Null if there have InterruptedException cause

Throws:

RejectedExecutionException - if the task cannot be scheduled for execution

NullPointerException - if runnable is null

See Also:

Future

executeAndWaitAll

public List<Future<?>> executeAndWaitAll(Runnable... runnable)
                                  throws RejectedExecutionException

convert to Callable and run executeAndWaitAll(Callable[])

Parameters:

runnable - the run task

Returns:

list of all task that represent the task that has been executed (Future.get() will return null if successful), or
Null if there have InterruptedException cause

Throws:

RejectedExecutionException - if the task cannot be scheduled for execution

NullPointerException - if runnable is null

See Also:

Future

executeAndWaitAny

public void executeAndWaitAny(Runnable... runnable)
                       throws RejectedExecutionException

convert to Callable and run executeAndWaitAny(Callable[])

Parameters:

runnable - the run task

Throws:

RejectedExecutionException - if the task cannot be scheduled for execution

NullPointerException - if runnable is null

See Also:

Future

shutdown

public void shutdown()

if create this class, you must shutdown it at last

isShutDown

public boolean isShutDown()

to check is this class already shutdown

Returns:

true, if already shutdown; otherwise, return false

See Also:

ExecutorService.shutdown()

isTerminate

public boolean isTerminate()

Inherit docs from ExecutorService.isTerminated()
Returns true if all tasks have completed following shut down. Note that isTerminated is never true unless either shutdown or shutdownNow was called first.

Returns:

true, if already terminal; otherwise, return false

See Also:

ExecutorService.isTerminated()

forceShutdown

public List<Runnable> forceShutdown()

force shutdown and return the task that not execute successfully.

Returns:

list of all task that not finish yet!, or null if all task is done or already shutdown the service

See Also:

ExecutorService.shutdownNow()

wait

public boolean wait(long time,
                    TimeUnit unit)
             throws InterruptedException

Blocks until all tasks have completed.
There are 3 ways that program can pass this method

1. Shutdown - user already call shutdown() or forceShutdown() ~ result will be Boolean.TRUE
2. Timeout - user the runnable/callable run/call exceed timeout interval ~ result will be Boolean.FALSE
3. Exception - when have exception while running the program ~ result will be InterruptedException

Parameters:

time - the maximum time for waiting

unit - the unit for waiting time

Returns:

true if successful terminate the thread, false if timeout

Throws:

InterruptedException - when error occurred while waiting

See Also:

ExecutorService.awaitTermination(long, TimeUnit)

doBackground

public static void doBackground(Runnable run)

do run on background using SwingWorker

Parameters:

run - runner code

doBackground

public static void doBackground(Runnable run,
                                Runnable done)

do run on background using SwingWorker

Parameters:

run - runner code

done - when run complete, it's will run this parameter

toRun

public static Runnable toRun(Callable<?> callable)

convert callable to runnable with ignore all exception and return value.

Parameters:

callable - call that want to conversion

Returns:

Runnable

toCall

public static <T> Callable<T> toCall(Runnable runnable,
                                     T returnValue)

convert runnable to callable with return value is parameter returnValue

Type Parameters:

T - the class of Callable generic type

Parameters:

runnable - run that want to conversion

returnValue - the return value

Returns:

Callable