Method Detail

• run

  <V> Future<V> run(Callable<V> code)

  Asynchronously executes the given code in a new thread, as decided by the thread service. Typically this means that the service allocates a thread from its pool, but ultimately the behavior is implementation-dependent. This method returns immediately.

  Parameters:

  code - The code to execute.

  Returns:

  A Future that will contain the result once the execution has finished. Call Future.get() to access to the return value (which will block until execution has completed).

• run

  Future<?> run(Runnable code)

  Asynchronously executes the given code in a new thread, as decided by the thread service. Typically this means that the service allocates a thread from its pool, but ultimately the behavior is implementation-dependent. This method returns immediately.

  Parameters:

  code - The code to execute.

  Returns:

  A Future that can be used to block until the execution has finished. Call Future.get() to do so.

• getExecutorService

  ExecutorService getExecutorService()

  Gets the ExecutorService object used when run(java.util.concurrent.Callable<V>) is called.

  Returns:

  the ExecutorService, or null if an ExecutorService is not used in this ThreadService implementation.

• setExecutorService

  void setExecutorService(ExecutorService executor)

  Sets the ExecutorService object used when run(java.util.concurrent.Callable<V>) is called.

  Parameters:

  executor - The ExecutorService for this ThreadService to use internally for run(java.util.concurrent.Callable<V>) calls.

  Throws:

  UnsupportedOperationException - if this ThreadService does not use an ExecutorService to handle run(java.util.concurrent.Callable<V>) calls.

• isDispatchThread

  boolean isDispatchThread()

  Gets whether the current thread is a dispatch thread for use with invoke(Runnable) and queue(Runnable).

  In the case of AWT-based applications (e.g., Java on the desktop), this is typically the AWT Event Dispatch Thread (EDT). However, ultimately the behavior is implementation-dependent.

  Returns:

  True iff the current thread is considered a dispatch thread.

• invoke

  void invoke(Runnable code)
       throws InterruptedException,
              InvocationTargetException

  Executes the given code in a special dispatch thread, blocking until execution is complete.

  In the case of AWT-based applications (e.g., Java on the desktop), this is typically the AWT Event Dispatch Thread (EDT). However, ultimately the behavior is implementation-dependent.

  Parameters:

  code - The code to execute.

  Throws:

  InterruptedException - If the code execution is interrupted.

  InvocationTargetException - If an uncaught exception occurs in the code during execution.

• queue

  void queue(Runnable code)

  Queues the given code for later execution in a special dispatch thread, returning immediately.

  In the case of AWT-based applications (e.g., Java on the desktop), this is typically the AWT Event Dispatch Thread (EDT). However, ultimately the behavior is implementation-dependent.

  Parameters:

  code - The code to execute.

• queue

  Future<?> queue(String id,
                  Runnable code)

  Queues the given code for later execution in a dispatch thread associated with the specified ID, returning immediately.

  Parameters:

  id - The ID designating which dispatch thread will execute the code.

  code - The code to execute.

  Returns:

  A Future whose Future.get() method blocks until the queued code has completed executing and returns null.

  See Also:

  ExecutorService.submit(Runnable)

• queue

  <V> Future<V> queue(String id,
                      Callable<V> code)

  Queues the given code for later execution in a dispatch thread associated with the specified ID, returning immediately.

  Parameters:

  id - The ID designating which dispatch thread will execute the code.

  code - The code to execute.

  Returns:

  A Future whose Future.get() method blocks until the queued code has completed executing and returns the result of the execution.

  See Also:

  ExecutorService.submit(Callable)

• getParent

  Thread getParent(Thread thread)

  Returns the thread that called the specified thread.

  This works only on threads which the thread service knows about, of course.

  Parameters:

  thread - the managed thread, null refers to the current thread

  Returns:

  the thread that asked the ThreadService to spawn the specified thread

• getThreadContext

  ThreadService.ThreadContext getThreadContext(Thread thread)

  Analyzes the Context of the given thread.

  Parameters:

  thread - The thread to analyze.

  Returns:

  Information about the thread's Context. Either:

  • ThreadService.ThreadContext.SAME - The thread was spawned by this very thread service, and thus shares the same Context.
  • ThreadService.ThreadContext.OTHER - The thread was spawned by a different thread service, and thus has a different Context.
  • ThreadService.ThreadContext.NONE - It is unknown what spawned the thread, so it is effectively Context-free.