This lesson teaches you to

You should also read

Try it out

The previous lesson showed you how to define a class that manages thread pools and the tasks
that run on them. This lesson shows you how to run a task on a thread pool. To do this,
you add the task to the pool's work queue. When a thread becomes available, the
ThreadPoolExecutor takes a task from the queue and runs it on the
thread.

This lesson also shows you how to stop a task that's running. You might want to do this if a
task starts, but then discovers that its work isn't necessary. Rather than wasting processor
time, you can cancel the thread the task is running on. For example, if you are downloading
images from the network and using a cache, you probably want to stop a task if it detects that
an image is already present in the cache. Depending on how you write your app, you may not be
able to detect this before you start the download.

Run a Task on a Thread in the Thread Pool

To start a task object on a thread in a particular thread pool, pass the
Runnable to ThreadPoolExecutor.execute(). This call adds the task to the thread pool's work queue. When an
idle thread becomes available, the manager takes the task that has been waiting the longest and
runs it on the thread:

To interrupt a thread, call Thread.interrupt(). Notice that
Thread objects are controlled by the system, which can modify them outside of
your app's process. For this reason, you need to lock access on a thread before you
interrupt it, by placing the access in a synchronized block. For example:

public class PhotoManager {
public static void cancelAll() {
/*
* Creates an array of Runnables that's the same size as the
* thread pool work queue
*/
Runnable[] runnableArray = new Runnable[mDecodeWorkQueue.size()];
// Populates the array with the Runnables in the queue
mDecodeWorkQueue.toArray(runnableArray);
// Stores the array length in order to iterate over the array
int len = runnableArray.length;
/*
* Iterates over the array of Runnables and interrupts each one's Thread.
*/
synchronized (sInstance) {
// Iterates over the array of tasks
for (int runnableIndex = 0; runnableIndex < len; runnableIndex++) {
// Gets the current thread
Thread thread = runnableArray[taskArrayIndex].mThread;
// if the Thread exists, post an interrupt to it
if (null != thread) {
thread.interrupt();
}
}
}
}
...
}

In most cases, Thread.interrupt() stops the thread
immediately. However, it only stops threads that are waiting, and will not interrupt CPU or
network-intensive tasks. To avoid slowing down or locking up the system, you should test for
any pending interrupt requests before attempting an operation :