xapi.gwt.process

Class ConcurrencyServiceGwt

java.lang.Object

xapi.process.impl.ConcurrencyServiceAbstract

xapi.gwt.process.ConcurrencyServiceGwt

All Implemented Interfaces:

ConcurrencyService

@SingletonOverride(implFor=ConcurrencyService.class)
public class ConcurrencyServiceGwt
extends ConcurrencyServiceAbstract

Nested Class Summary

Nested classes/interfaces inherited from class xapi.process.impl.ConcurrencyServiceAbstract

ConcurrencyServiceAbstract.EnviroMap, ConcurrencyServiceAbstract.WrappedRunnable

Constructor Summary

Constructors

Constructor and Description
ConcurrencyServiceGwt()

Method Summary

Modifier and Type	Method and Description
protected ConcurrentEnvironment	initializeEnvironment(Thread key, Thread.UncaughtExceptionHandler params)
AsyncLock	newLock()
double	now()
void	runDeferred(Runnable cmd) Runs the given command in a new environment, after all finalies have been processed.
void	runEventually(Runnable cmd) Runs the command eventually, most likely on an unused thread.
void	runFinally(Runnable cmd) Runs the given command after the work queue for the current environment is drained.
void	runTimeout(Runnable cmd, int millisToWait) Wait (at least) a given number of milliseconds to perform a task.
boolean	trySleep(float millis) Attempts to sleep, if the current thread is not interrupted.

Methods inherited from class xapi.process.impl.ConcurrencyServiceAbstract

callback, currentEnvironment, flush, getFuturesThread, initMap, isMultiThreaded, kill, newProcess, newThread, resolve, threadFlushTime, threadStartTime, wrap

Methods inherited from class java.lang.Object

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

Constructor Detail

ConcurrencyServiceGwt

public ConcurrencyServiceGwt()

Method Detail

initializeEnvironment

protected ConcurrentEnvironment initializeEnvironment(Thread key,
                                                      Thread.UncaughtExceptionHandler params)

Specified by:

initializeEnvironment in class ConcurrencyServiceAbstract

runDeferred

public void runDeferred(Runnable cmd)

Description copied from interface: ConcurrencyService

Runs the given command in a new environment, after all finalies have been processed.

Specified by:

runDeferred in interface ConcurrencyService

Overrides:

runDeferred in class ConcurrencyServiceAbstract

Parameters:

cmd - - The task to run.

runFinally

public void runFinally(Runnable cmd)

Description copied from interface: ConcurrencyService

Runs the given command after the work queue for the current environment is drained. Finalies must always be cleared before a given unit of work is truly "finished". You may safely schedule multiple layers of finally blocks from other finally blocks; the queue is copied and reset for every iteration. Just beware that this enforces "single-threadedness", and will cause blocking in a concurrent environment. In GWT, it will not release the processing thread for UI updates until all finalies are complete.

Specified by:

runFinally in interface ConcurrencyService

Overrides:

runFinally in class ConcurrencyServiceAbstract

Parameters:

cmd - - The command to run after the work queue is drained.

runTimeout

public void runTimeout(Runnable cmd,
                       int millisToWait)

Description copied from interface: ConcurrencyService

Wait (at least) a given number of milliseconds to perform a task. Exact timing promises are not made, so if you need an exact timing in a concurrent environment, schedule your deadline 10-50 millis early, or even better, track latency (how much later you are called then requested) and adjust your timeouts accordingly.

Parameters:

cmd - - The command to run.

millisToWait - - A minimum of milliseconds to wait.

runEventually

public void runEventually(Runnable cmd)

Description copied from interface: ConcurrencyService

Runs the command eventually, most likely on an unused thread. This is good for cleaning up memory or doing other house-keeping chores only when there isn't any other work to do. Each implementation may handle eventualies different, and no guarantee is made about what order your command is run (it could be run immediately in a parallel thread, or it could wait a few minutes until a thread-hungry process is complete, and get cleared by starving threads before they are released.

Specified by:

runEventually in interface ConcurrencyService

Overrides:

runEventually in class ConcurrencyServiceAbstract

Parameters:

cmd - - A command to run whenever there is time. No guarantee is made about how soon or how later the process is run. A best-effort is made to use warm threads with nothing better to do to process eventually commands.

newLock

public AsyncLock newLock()

Returns:

A lock suitable for the environment in which you are running. We may extend the Lock interface, and require subclasses that offer a given, small set of additional functionality.

trySleep

public boolean trySleep(float millis)

Description copied from interface: ConcurrencyService

Attempts to sleep, if the current thread is not interrupted. Experiments with rewriting AST in GWT may make "pseudo-sleep" possible, by travelling up the method call to the nearest method with void return type, and moving all code into a scoped callback function. Such experiments will not likely yield useful rewards, but will be carried out anyway. Until then, sleep is a no-op in GWT. When the GwtThread class is complete, calling sleep will tell the ConcurrencyService to stop running tasks from this thread until the given timeout is expired.

Specified by:

trySleep in interface ConcurrencyService

Overrides:

trySleep in class ConcurrencyServiceAbstract

Parameters:

millis - - The millis to wait. Floating point converts to nanos.

Returns:

- true is wait was successful and we are not in an interrupted state.

now

public double now()

Specified by:

now in interface ConcurrencyService

Overrides:

now in class ConcurrencyServiceAbstract

Returns:

Current nano-time, since TimeService.birth().