edu.stanford.nlp.util.concurrent

Class InterruptibleMulticoreWrapper<I,O>

java.lang.Object

edu.stanford.nlp.util.concurrent.MulticoreWrapper<I,O>

edu.stanford.nlp.util.concurrent.InterruptibleMulticoreWrapper<I,O>

public class InterruptibleMulticoreWrapper<I,O>
extends MulticoreWrapper<I,O>

Constructor Summary

Constructors

Constructor and Description
InterruptibleMulticoreWrapper(int numThreads, ThreadsafeProcessor<I,O> processor, boolean orderResults, long timeout) Create an interruptible thread pool for multithreaded processing.

Method Summary

Modifier and Type	Method and Description
boolean	awaitTermination(long timeout, java.util.concurrent.TimeUnit unit) After a shutdown request, await for the final termination of all threads.
protected java.util.concurrent.ThreadPoolExecutor	buildThreadPool(int nThreads)
protected java.lang.Integer	getProcessor() Returns the next available thread id.
java.util.List<I>	joinWithTimeout() Shuts down the thread pool, returns when finished.

Methods inherited from class edu.stanford.nlp.util.concurrent.MulticoreWrapper

join, join, nThreads, peek, poll, put, toString

Methods inherited from class java.lang.Object

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

Constructor Detail

InterruptibleMulticoreWrapper

public InterruptibleMulticoreWrapper(int numThreads,
                                     ThreadsafeProcessor<I,O> processor,
                                     boolean orderResults,
                                     long timeout)

Create an interruptible thread pool for multithreaded processing.

Parameters:

numThreads - If less than or equal to 0, then automatically determine the number of threads. Otherwise, the size of the underlying threadpool.

processor - The processor (factory) for what will be run on data.

orderResults - If true, return results in the order submitted. Otherwise, return results as they become available.

timeout - If timeout is a positive number, the threadpool attempts to allow jobs to run for only this many milliseconds, but it depends on threads being Interruptible to succeed. If zero or negative, thread runtime is unlimited.

Method Detail

buildThreadPool

protected java.util.concurrent.ThreadPoolExecutor buildThreadPool(int nThreads)

Overrides:

buildThreadPool in class MulticoreWrapper<I,O>

getProcessor

protected java.lang.Integer getProcessor()

Description copied from class: MulticoreWrapper

Returns the next available thread id. Subclasses may wish to override this, for example if they implement a timeout

joinWithTimeout

public java.util.List<I> joinWithTimeout()

Shuts down the thread pool, returns when finished.

If timeout is positive, then join waits at most timeout milliseconds for threads to finish. If any fail to finish in that time, the threadpool is shutdownNow. After that, join continues to wait for the interrupted threads to finish, so if job do not obey interruptions, they can continue indefinitely regardless of the timeout.

Returns:

a list of jobs which had never been started if timeout was reached, or an empty list if that did not happen.

awaitTermination

public boolean awaitTermination(long timeout,
                                java.util.concurrent.TimeUnit unit)
                         throws java.lang.InterruptedException

After a shutdown request, await for the final termination of all threads. Note that if the threads don't actually obey the interruption, this may take some time.

Throws:

java.lang.InterruptedException