Achieve strong performance with threads,
Part 1
Tutorial Details:
Achieve strong performance with threads, Part 1
Achieve strong performance with threads, Part 1
By: By Jeff Friesen
Introducing threads, the Thread class, and runnables
sers hate unresponsive software. When users click a mouse, they expect a program to instantly respond to their requests, even when the program is in the midst of a time-consuming activity, such as repaginating a long document or waiting for a network operation to complete. Programs that respond slowly to their users exhibit poor performance. To improve a program's performance, developers typically use threads.
This article is the first in a four-part series that explores threads. Although you might think threads a difficult subject to grasp, I intend to show you that threads are easy to understand. In this article, I introduce you to threads and the Thread class, and discuss runnables. Furthermore, the accompanying sidebar, " Exceptions and the run() Method " discusses exceptions in the context of a thread object's run() method. In subsequent articles, I will explore synchronization (via locks), synchronization problems (such as deadlock), the wait/notify mechanism, scheduling (with and without priority), thread interruption, timers, volatility, thread groups, and thread local variables.
Read the whole series on thread programming:
Part 1: Introducing threads, the Thread class, and runnables
Part 2: Use synchronization to serialize thread access to critical code sections
Part 3: Learn about thread scheduling, the wait/notify mechanism, and thread interruption
Part 4: Discover thread groups, volatility, thread-local variables, timers, and the ThreadDeath class
Note
This article and its three companions examine threads in the context of applications, as opposed to applets. However, much of what I present in the application context applies to applets. The main difference: For security reasons, not all thread operations are possible within an applet (I will discuss applets in a future article).
What is a thread?
Conceptually, the notion of a thread is not difficult to grasp: it's an independent path of execution through program code. When multiple threads execute, one thread's path through the same code usually differs from the others. For example, suppose one thread executes the byte code equivalent of an if-else statement's if part, while another thread executes the byte code equivalent of the else part. How does the JVM keep track of each thread's execution? The JVM gives each thread its own method-call stack. In addition to tracking the current byte code instruction, the method-call stack tracks local variables, parameters the JVM passes to a method, and the method's return value.
When multiple threads execute byte-code instruction sequences in the same program, that action is known as multithreading . Multithreading benefits a program in various ways:
Multithreaded GUI (graphical user interface)-based programs remain responsive to users while performing other tasks, such as repaginating or printing a document.
Threaded programs typically finish faster than their nonthreaded counterparts. This is especially true of threads running on a multiprocessor machine, where each thread has its own processor.
Java accomplishes multithreading through its java.lang.Thread class. Each Thread object describes a single thread of execution. That execution occurs in Thread 's run() method. Because the default run() method does nothing, you must subclass Thread and override run() to accomplish useful work. For a taste of threads and multithreading in the context of Thread , examine Listing 1:
Listing 1. ThreadDemo.java
// ThreadDemo.java
class ThreadDemo
{
public static void main (String [] args)
{
MyThread mt = new MyThread ();
mt.start ();
for (int i = 0; i < 50; i++)
System.out.println ("i = " + i + ", i * i = " + i * i);
}
}
class MyThread extends Thread
{
public void run ()
{
for (int count = 1, row = 1; row < 20; row++, count++)
{
for (int i = 0; i < count; i++)
System.out.print ('*');
System.out.print ('\n');
}
}
}
Listing 1 presents source code to an application consisting of classes ThreadDemo and MyThread . Class ThreadDemo drives the application by creating a MyThread object, starting a thread that associates with that object, and executing some code to print a table of squares. In contrast, MyThread overrides Thread 's run() method to print (on the standard output stream) a right-angle triangle composed of asterisk characters.
When you type java ThreadDemo to run the application, the JVM creates a starting thread of execution, which executes the main() method. By executing mt.start (); , the starting thread tells the JVM to create a second thread of execution that executes the byte code instructions comprising the MyThread object's run() method. When the start() method returns, the starting thread executes its for loop to print a table of squares, while the new thread executes the run() method to print the right-angle triangle.
What does the output look like? Run ThreadDemo to find out. You will notice each thread's output tends to intersperse with the other's output. That results because both threads send their output to the same standard output stream.
Note
Most (if not all) JVM implementations use the underlying platform's threading capabilities. Because those capabilities are platform-specific, the order of your multithreaded programs' output might differ from the order of someone else's output. That difference results from scheduling, a topic I explore later in this series.
The Thread class
To grow proficient at writing multithreaded code, you must first understand the various methods that make up the Thread class. This section explores many of those methods. Specifically, you learn about methods for starting threads, naming threads, putting threads to sleep, determining whether a thread is alive, joining one thread to another thread, and enumerating all active threads in the current thread's thread group and subgroups. I also discuss Thread 's debugging aids and user threads versus daemon threads.
I'll present the remainder of Thread 's methods in subsequent articles, with the exception of Sun's deprecated methods.
Caution
Sun has deprecated a variety of Thread methods, such as suspend() and resume() , because they can lock up your programs or damage objects. As a result, you should not call them in your code. Consult the SDK documentation for workarounds to those methods. I do not cover deprecated methods in this series.
Construct threads
Thread has eight constructors. The simplest are:
Thread() , which creates a Thread object with a default name
Thread(String name) , which creates a Thread object with a name that the name argument specifies
The next simplest constructors are Thread(Runnable target) and Thread(Runnable target, String name) . Apart from the Runnable parameters, those constructors are identical to the aforementioned constructors. The difference: The Runnable parameters identify objects outside Thread that provide the run() methods. (You learn about Runnable later in this article.) The final four constructors resemble Thread(String name) , Thread(Runnable target) , and Thread(Runnable target, String name) ; however, the final constructors also include a ThreadGroup argument for organizational purposes.
One of the final four constructors, Thread(ThreadGroup group, Runnable target, String name, long stackSize) , is interesting in that it lets you specify the desired size of the thread's method-call stack. Being able to specify that size proves helpful in programs with methods that utilize recursion?an execution technique whereby a method repeatedly calls itself?to elegantly solve certain problems. By explicitly setting the stack size, you can sometimes prevent StackOverflowError s. However, too large a size can result in OutOfMemoryError s. Also, Sun regards the method-call stack's size as platform-dependent. Depending on the platform, the method-call stack's size might change. Therefore, think carefully about the ramifications to your program before writing code that calls Thread(ThreadGroup group, Runnable target, String name, long stackSize) .
Start your vehicles
Threads resemble vehicles: they move programs from start to finish. Thread and Thread subclass objects are not threads. Instead, they describe a thread's attributes, such as its name, and contain code (via a run() method) that the thread executes. When the time comes for a new thread to execute run() , another thread calls the Thread 's or its subclass object's start() method. For example, to start a second thread, the application's starting thread?which executes main() ?calls start() . In response, the JVM's thread-handling code works with the platform to ensure the thread properly initializes and calls a Thread 's or its subclass object's run() method.
Once start() completes, multiple threads execute. Because we tend to think in a linear fashion, we often find it difficult to understand the concurrent (simultaneous) activity that occurs when two or more threads are running. Therefore, you should examine a chart that shows where a thread is executing (its position) versus time. The figure below presents such a chart.
The behaviors of a starting thread's and a newly created thread's execution positions versus time
The chart shows several significant time periods:
The starting thread's initialization
The moment that thread begins to execute main()
The moment that thread begins to execute start()
The moment start() creates a new thread and returns to main()
The new thread's initialization
The moment the new thread begins to execute run()
The different moments each thread terminates
Note that the new thread's initialization, its execution of run() , and its termination happen simultaneously with the starting thread's execution.
Caution
After a thread calls start() , subsequent calls to that method be
Read
Tutorial at: Click here to view the tutorial
Rate Tutorial: Achieve strong performance with threads,
Part 1
View Tutorial: Achieve strong performance with threads,
Part 1
Related
Tutorials:
 Programming Java threads in the
real world, Part
1 - JavaWorld -
September 1998
Programming Java threads in the
real world, Part
1 - JavaWorld -
September 1998
|
The Java HotSpot
Performance Engine is set to break new records - JavaWorld
The Java HotSpot
Performance Engine is set to break new records - JavaWorld
|
A promise of easier
embedded-systems networking - JavaWorld November 1999
A promise of easier
embedded-systems networking - JavaWorld November 1999
|
Smart object-management saves the
day - JavaWorld November 1999
Smart object-management saves the
day - JavaWorld November 1999
|
Java performance programming,
Part 3: Managing collections - JavaWorld February 2000
Java performance programming,
Part 3: Managing collections - JavaWorld February 2000
|
Java threads may not use all your CPUs - JavaWorld August 2000
Java threads may not use all your CPUs - JavaWorld August 2000
|
Activatable Jini services, Part 2: Patterns of use
- JavaWorld
October 2000
Activatable Jini services, Part 2: Patterns of use
- JavaWorld
October 2000
|
Construct secure
networked applications with certificates, Part 1 - JavaWorld January
2001
Construct secure
networked applications with certificates, Part 1 - JavaWorld January
2001
|
Performance books put to the test - JavaWorld March 2001
Performance books put to the test - JavaWorld March 2001
|
J2EE project
dangers! - JavaWorld March 2001
J2EE project
dangers! - JavaWorld March 2001
|
Avoid synchronization
deadlocks
Avoid synchronization
deadlocks
|
Can ThreadLocal solve the double-checked locking
problem?
Can ThreadLocal solve the double-checked locking
problem?
|
I want my AOP!, Part 3
I want my AOP!, Part 3
|
Achieve strong performance with threads,
Part 1
Achieve strong performance with threads,
Part 1
|
Study guide Achieve strong performance with threads
Part 1
Study guide Achieve strong performance with threads
Part 1
|
Achieve strong performance with threads,
Part 2
Achieve strong performance with threads,
Part 2
|
Get the inside
track on J2EE architect certification
Get the inside
track on J2EE architect certification
|
Very
interesting
Very
interesting
|
The ABCs of Synchronization, Part 1
Threads may execute in a manner where their paths of execution are completely independent of each other. Neither thread depends upon the other for assistance. For example, one thread might execute a print job, while a second thread repaints a window. And
|
Access Windows Performance Monitor counters from Java, Part 1
Access Windows Performance Monitor counters from Java, Part 1
Use a simple Java API to gather valuable performance statistics
Summary
Windows NT, 2000, 2003, and XP contain a utility called the Performance Monitor that provides a rich array of perform
|
|
|
|
