Threads and Concurrent Programming
Threads may be seen as methods that execute at "the same time" as other methods. Normally, we think sequentially when writing a computer program. From this perspective, only one thing executes at a time. However, with today's multi-core processors, it is possible to literally have several things going on at the very same time while sharing the same memory. There are lots of ways that this is done in the real world, and this chapter goes over them in a way that you can apply to your own projects.
14.5 Using Threads to Improve Interface Responsiveness
Advantages of Multithreaded Design
By creating a separate thread for Dotty, we have turned a single-threaded program into a multithreaded program. One thread, the GUI, handles the user interface. The second thread handles the drawing task. By forcing the drawing to sleep on each iteration, we guarantee that the GUI thread will remain responsive to the user’s actions. Figure 14.16 illustrates the difference between the single- and multithreaded designs. Note that the GUI thread starts and stops the drawing thread, and the GUI thread executes dotty.clear(). The drawing thread simply executes its draw() method. In the single-threaded version, all of these actions are done by one thread.
The trade-off involved in this design is that it will take longer to draw
N random dots, since dottyThread.draw() will sleep for an instant on each iteration. However, the extra time is hardly noticeable. By breaking
the program into two separate threads of control, one to handle the drawing task and one to handle the user interface, the result is a much more
responsive program.
Figure 14.16: Two independent
threads: one for drawing, the
other for the GUI.
SELF-STUDY EXERCISES
EXERCISE 14.7 Someone might argue that because the Java Virtual Machine uses a round-robin scheduling algorithm, it’s redundant to use the sleep() method, since the GUI thread will get its chance to run. What’s wrong with this argument for interface responsiveness?
EXERCISE 14.8 Instead of sleeping on each iteration, another way to
make the interface more responsive would be to set the threaded Dotty’s
priority to a low number, such as 1. Make this change, and experiment
with its effect on the program’s responsiveness. Is it more or less responsive than sleeping on each iteration? Why?