com.qualcomm.robotcore.util

Class ThreadPool

java.lang.Object

com.qualcomm.robotcore.util.ThreadPool

public class ThreadPool
extends java.lang.Object

The ThreadPool class manages thread creation and shutdown in the SDK. We centralize things here mostly so as to provide robust logging services that will aid in postmortem analysis of system issues.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static interface	ThreadPool.ContainerOfThreads
static class	ThreadPool.RecordingScheduledExecutor
static class	ThreadPool.RecordingThreadPool
static class	ThreadPool.Singleton<T> Singletons are helpers that gatekeep execution of work on a service to a single runnable at a time.
static class	ThreadPool.SingletonResult<T> SingletonResults are returned from Singletons as a token that can be used to await the completion of submitted work.
static interface	ThreadPool.ThreadBorrowable Indicates a thread pool that is at times capable of using guest worker threads

Field Summary

Fields

Modifier and Type	Field and Description
static java.lang.String	TAG

Constructor Summary

Constructors

Constructor and Description
ThreadPool()

Method Summary

Modifier and Type	Method and Description
static boolean	awaitFuture(java.util.concurrent.Future future, long timeout, java.util.concurrent.TimeUnit unit)
static boolean	awaitTermination(java.util.concurrent.ExecutorService executorService, long timeout, java.util.concurrent.TimeUnit unit, java.lang.String serviceName) Waits for the indicated timeout for the indicated executor service to shutdown.
static void	awaitTerminationOrExitApplication(java.util.concurrent.ExecutorService executorService, long timeout, java.util.concurrent.TimeUnit unit, java.lang.String serviceName, java.lang.String message) Awaits the termination of the indicated service for the indicated timeout.
static void	cancelFutureOrExitApplication(java.util.concurrent.Future future, long timeout, java.util.concurrent.TimeUnit unit, java.lang.String serviceName, java.lang.String message)
static void	exitApplication(java.lang.String serviceName, java.lang.String message)
static java.util.concurrent.ExecutorService	getDefault()
static java.util.concurrent.ScheduledExecutorService	getDefaultScheduler()
static java.util.concurrent.ExecutorService	getDefaultSerial()
static int	getTID(long threadId) Returns the OS-level thread id for the indicated Android-level thread id
static int	getTID(java.lang.Thread thread) Returns the OS-level thread id for the given thread
static void	logThreadLifeCycle(java.lang.String name, java.lang.Runnable runnable) Robustly log thread startup and shutdown
static java.util.concurrent.ExecutorService	newCachedThreadPool(java.lang.String nameRoot) Creates a thread pool that creates new threads as needed, but will reuse previously constructed threads when they are available.
static java.util.concurrent.ExecutorService	newFixedThreadPool(int numberOfThreads, java.lang.String nameRoot) Creates a thread pool that reuses a fixed number of threads operating off a shared unbounded queue.
static ThreadPool.RecordingScheduledExecutor	newScheduledExecutor(int maxWorkerThreadCount, java.lang.String nameRoot) Creates an executor that can schedule commands to run after a given delay, or to execute periodically.
static java.util.concurrent.ExecutorService	newSingleThreadExecutor(java.lang.String nameRoot) Creates an Executor that uses a single worker thread operating off an unbounded queue.
protected static java.lang.Throwable	retrieveUserException(java.lang.Runnable r, java.lang.Throwable t)

Methods inherited from class java.lang.Object

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

Field Detail

TAG

public static final java.lang.String TAG

See Also:

Constant Field Values

Constructor Detail

ThreadPool

public ThreadPool()

Method Detail

getDefault

public static java.util.concurrent.ExecutorService getDefault()

getDefaultSerial

public static java.util.concurrent.ExecutorService getDefaultSerial()

getDefaultScheduler

public static java.util.concurrent.ScheduledExecutorService getDefaultScheduler()

newSingleThreadExecutor

public static java.util.concurrent.ExecutorService newSingleThreadExecutor(java.lang.String nameRoot)

Creates an Executor that uses a single worker thread operating off an unbounded queue.

See Also:

Executors.newSingleThreadExecutor()

newFixedThreadPool

public static java.util.concurrent.ExecutorService newFixedThreadPool(int numberOfThreads,
                                                                      java.lang.String nameRoot)

Creates a thread pool that reuses a fixed number of threads operating off a shared unbounded queue. At any point, at most numberOfThreads threads will be active processing tasks.

See Also:

Executors.newFixedThreadPool(int)

newCachedThreadPool

public static java.util.concurrent.ExecutorService newCachedThreadPool(java.lang.String nameRoot)

Creates a thread pool that creates new threads as needed, but will reuse previously constructed threads when they are available.

See Also:

Executors.newCachedThreadPool()

newScheduledExecutor

public static ThreadPool.RecordingScheduledExecutor newScheduledExecutor(int maxWorkerThreadCount,
                                                                         java.lang.String nameRoot)

Creates an executor that can schedule commands to run after a given delay, or to execute periodically. The pool has a minimum size of 1, but will expand as necessary to accommodate its workload.

See Also:

Executors.newSingleThreadScheduledExecutor()

getTID

public static int getTID(java.lang.Thread thread)

Returns the OS-level thread id for the given thread

getTID

public static int getTID(long threadId)

Returns the OS-level thread id for the indicated Android-level thread id

awaitTermination

public static boolean awaitTermination(java.util.concurrent.ExecutorService executorService,
                                       long timeout,
                                       java.util.concurrent.TimeUnit unit,
                                       java.lang.String serviceName)
                                throws java.lang.InterruptedException

Waits for the indicated timeout for the indicated executor service to shutdown. Will return early if an interrupt occurs. If the shutdown is particularly lengthy, then at periodic intervals (on the order of seconds) messages are recorded to the log to aid in postmortem analyses.

Parameters:

executorService - the service to shutdown

timeout - the duration to wait for the shutdown

unit - the units in which the timeout parameter is provided

serviceName - the name of the service as it is to be recorded in the log

Returns:

whether or not the service was seen to terminate within the allotted timeout

Throws:

java.lang.InterruptedException

awaitTerminationOrExitApplication

public static void awaitTerminationOrExitApplication(java.util.concurrent.ExecutorService executorService,
                                                     long timeout,
                                                     java.util.concurrent.TimeUnit unit,
                                                     java.lang.String serviceName,
                                                     java.lang.String message)

Awaits the termination of the indicated service for the indicated timeout. If the service terminates, then the function returns. If the service does not terminate within the alloted time, then a bold message is written to the log and the application is terminated.

Parameters:

executorService - the executor service whose termination we are to await

timeout - the timeout we are to permit

unit - the units in which timeout is expressed

serviceName - a human-understandable name for the executor service

message - the message to print if we terminate the app

awaitFuture

public static boolean awaitFuture(java.util.concurrent.Future future,
                                  long timeout,
                                  java.util.concurrent.TimeUnit unit)

Returns:

whether we know the future has stopped its work or not

cancelFutureOrExitApplication

public static void cancelFutureOrExitApplication(java.util.concurrent.Future future,
                                                 long timeout,
                                                 java.util.concurrent.TimeUnit unit,
                                                 java.lang.String serviceName,
                                                 java.lang.String message)

exitApplication

public static void exitApplication(java.lang.String serviceName,
                                   java.lang.String message)

logThreadLifeCycle

public static void logThreadLifeCycle(java.lang.String name,
                                      java.lang.Runnable runnable)

Robustly log thread startup and shutdown

retrieveUserException

protected static java.lang.Throwable retrieveUserException(java.lang.Runnable r,
                                                           java.lang.Throwable t)

See Also:

ThreadPoolExecutor#afterExecute(Runnable, Throwable), after which this logic is modelled