Package org.scijava.thread

Class DefaultThreadService

java.lang.Object

org.scijava.AbstractContextual

org.scijava.plugin.AbstractRichPlugin

org.scijava.service.AbstractService

org.scijava.thread.DefaultThreadService

All Implemented Interfaces:

Comparable<Prioritized>, ThreadFactory, Contextual, Disposable, Identifiable, Initializable, Locatable, Logged, HasPluginInfo, RichPlugin, SciJavaPlugin, Prioritized, SciJavaService, Service, ThreadService, Versioned

public final class DefaultThreadService
extends AbstractService
implements ThreadService

Default service for managing active threads.

Author:

Curtis Rueden

Nested Class Summary

Nested classes/interfaces inherited from interface org.scijava.thread.ThreadService

ThreadService.ThreadContext

Constructor Summary

Constructors

Constructor	Description
DefaultThreadService()

Method Summary

Modifier and Type	Method	Description
void	dispose()	Performs any needed cleanup of the object's services, in preparation for the object being retired (e.g., to make garbage collection possible).
ExecutorService	getExecutorService()	Gets the ExecutorService object used when ThreadService.run(java.util.concurrent.Callable<V>) is called.
Thread	getParent(Thread thread)	Returns the thread that called the specified thread.
ThreadService.ThreadContext	getThreadContext(Thread thread)	Analyzes the Context of the given thread.
void	invoke(Runnable code)	Executes the given code in a special dispatch thread, blocking until execution is complete.
boolean	isDispatchThread()	Gets whether the current thread is a dispatch thread for use with ThreadService.invoke(Runnable) and ThreadService.queue(Runnable).
Thread	newThread(Runnable r)
void	queue(Runnable code)	Queues the given code for later execution in a special dispatch thread, returning immediately.
Future<?>	queue(String id, Runnable code)	Queues the given code for later execution in a dispatch thread associated with the specified ID, returning immediately.
<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.
Future<?>	run(Runnable code)	Asynchronously executes the given code in a new thread, as decided by the thread service.
<V> Future<V>	run(Callable<V> code)	Asynchronously executes the given code in a new thread, as decided by the thread service.
void	setExecutorService(ExecutorService executor)	Sets the ExecutorService object used when ThreadService.run(java.util.concurrent.Callable<V>) is called.

Methods inherited from class org.scijava.service.AbstractService

getContext, setContext, toString

Methods inherited from class org.scijava.plugin.AbstractRichPlugin

getInfo, getPriority, setInfo, setPriority

Methods inherited from class org.scijava.AbstractContextual

context

Methods inherited from class java.lang.Object

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

Methods inherited from interface org.scijava.Contextual

context, getContext, setContext

Methods inherited from interface org.scijava.plugin.HasPluginInfo

getInfo, setInfo

Methods inherited from interface org.scijava.Locatable

getLocation

Methods inherited from interface org.scijava.Prioritized

compareTo, getPriority, setPriority

Methods inherited from interface org.scijava.plugin.RichPlugin

getIdentifier, log

Methods inherited from interface org.scijava.service.Service

initialize, registerEventHandlers

Methods inherited from interface org.scijava.Versioned

getVersion

Constructor Detail

DefaultThreadService

public DefaultThreadService()

Method Detail

run

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

Description copied from interface: ThreadService

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.

Specified by:

run in interface ThreadService

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

public Future<?> run(Runnable code)

Description copied from interface: ThreadService

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.

Specified by:

run in interface ThreadService

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

public ExecutorService getExecutorService()

Description copied from interface: ThreadService

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

Specified by:

getExecutorService in interface ThreadService

Returns:

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

setExecutorService

public void setExecutorService(ExecutorService executor)

Description copied from interface: ThreadService

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

Specified by:

setExecutorService in interface ThreadService

Parameters:

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

isDispatchThread

public boolean isDispatchThread()

Description copied from interface: ThreadService

Gets whether the current thread is a dispatch thread for use with ThreadService.invoke(Runnable) and ThreadService.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.

Specified by:

isDispatchThread in interface ThreadService

Returns:

True iff the current thread is considered a dispatch thread.

invoke

public void invoke(Runnable code)
            throws InterruptedException,
                   InvocationTargetException

Description copied from interface: ThreadService

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.

Specified by:

invoke in interface ThreadService

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

public void queue(Runnable code)

Description copied from interface: ThreadService

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.

Specified by:

queue in interface ThreadService

Parameters:

code - The code to execute.

queue

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

Description copied from interface: ThreadService

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

Specified by:

queue in interface ThreadService

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

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

Description copied from interface: ThreadService

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

Specified by:

queue in interface ThreadService

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

public Thread getParent(Thread thread)

Description copied from interface: ThreadService

Returns the thread that called the specified thread.

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

Specified by:

getParent in interface ThreadService

Parameters:

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

Returns:

the thread that asked the ThreadService to spawn the specified thread

getThreadContext

public ThreadService.ThreadContext getThreadContext(Thread thread)

Description copied from interface: ThreadService

Analyzes the Context of the given thread.

Specified by:

getThreadContext in interface ThreadService

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.

dispose

public void dispose()

Description copied from interface: Disposable

Performs any needed cleanup of the object's services, in preparation for the object being retired (e.g., to make garbage collection possible).

Specified by:

dispose in interface Disposable

newThread

public Thread newThread(Runnable r)

Specified by:

newThread in interface ThreadFactory