Java Reference
In-Depth Information
Worker Thread
Also known as Background Thread, Thread Pool
Pattern Properties
Type: Processing
Level: Architectural
Purpose
To improve throughput and minimize average latency.
Introduction
When you introduce threading to an application, your main goal is to use threads to eliminate bottlenecks.
However, it requires skill to implement correctly. One way to maximize efficiency in a multithreaded application
is to take advantage of the fact that not all threaded tasks have the same priority. For some of the tasks that need
to be performed, timing is crucial. For others, they just need to be executed; exactly when isn't important.
To save yourself some long nights, you can separate these tasks from the rest of your application and use the
Worker Thread pattern. The worker thread picks up a task from a queue and executes it; when it's finished, it just
picks up the next task from the queue.
Threading is easier with Worker Thread because when you want something done, but not specifically now, you
put it in the queue. And your code will become easier to read because all the thread object issues are in the worker
thread and the queue.
Applicability
Use Worker Thread when:
You want to improve throughput
You want to introduce concurrency
Description
One approach to implementing threads is as follows: when you start a new task, create a new
Thread
object and
start it. The thread performs its designated task, then dies. That's simple enough. However, creating the thread
instance is very expensive in terms of performance, it takes a lot of time, and you only get one task out of it. A
more efficient approach is to create a longer-lived “worker thread” that performs many tasks for you, one after the
other.
That's the essence of the Worker Thread pattern. The worker thread executes many unrelated tasks, one after the
other. Instead of creating a new thread whenever you have a new task, you give the task to the existing worker
thread, which handles the task for you.
The Worker Thread might still be handling the first task when you're ready to hand it the next task. Solutions
include the following:
Your application waits until the Worker Thread becomes available again, but that kills a lot of the benefit you
gain from multithreading.
Your application creates a new instance of the worker thread each time the other worker thread is unavailable, but
then you're back at square one—creating a new thread each time you have a new task.
The solution to this problem of the temporarily unavailable thread is to store the tasks until the worker thread is
available again. The new task is stored in a queue and when the worker thread has finished with a task, it checks
the queue and takes the next task. The task doesn't get performed any sooner, but at least your application isn't
standing around waiting to hand off the task. If there are no tasks, it waits for the next task to arrive. Putting a task
on the queue is less expensive than creating a new thread.
