MODULE5_EXCEPTION HANDLING.docx

An exception is an abnormal condition that arises in a code sequence at run time. In other
words, an exception is a run-time error. In computer languages that do not support exception
handling, errors must be checked and handled manually—typically through the use of error
codes, and so on. This approach is as cumbersome as it is troublesome. Java’s exception
handling avoids these problems and, in the process, brings run-time error management into the
object oriented world.
Exception-Handling Fundamentals
AJava exception is an object that describes an exceptional (that is, error) condition that has
occurred in a piece of code. When an exceptional condition arises, an object representing that
exception is created and thrown in the method that caused the error. That method may choose
to handle the exception itself, or pass it on. Either way, at some point, the exception is caught
and processed. Exceptions can be generated by the Java run-time system, or they can be
manually generated by your code. Exceptions thrown by Java relate to fundamental errors that
violate the rules of the Java language or the constraints of the Java execution environment.
Manually generated exceptions are typically used to report some error condition to the caller
of a method.
Java exception handling is managed via five keywords: try, catch, throw, throws, and finally.
Briefly, here is how they work. Program statements that you want to monitor for exceptions
are contained within a try block. If an exception occurs within the try block, it is thrown. Your
code can catch this exception (using catch) and handle it in some rational manner.
System-generated exceptions are automatically thrown by the Java run-time system. To
manually throw an exception, use the keyword throw. Any exception that is thrown out of a
method must be specified as such by a throws clause. Any code that absolutely must be
executed after a try block completes is put in a finally block.
This is the general form of an exception-handling block:
try {
// block of code to monitor for errors
}
catch (ExceptionType1 exOb) {
// exception handler for ExceptionType1
}
catch (ExceptionType2 exOb) {

// exception handler for ExceptionType2
}
// ...
finally {
// block of code to be executed after try block ends
}
Here, ExceptionType is the type of exception that has occurred. The remainder of this chapter
describes how to apply this framework.
Exception Types
All exception types are subclasses of the built-in class Throwable. Thus, Throwable is at the
top of the exception class hierarchy. Immediately below Throwable are two subclasses that
partition exceptions into two distinct branches. One branch is headed by Exception. This class
is used for exceptional conditions that user programs should catch. This is also the class that
you will subclass to create your own custom exception types. There is an important subclass
of Exception, called RuntimeException. Exceptions of this type are automatically defined for
the programs that you write and include things such as division by zero and invalid array
indexing.
The other branch is topped by Error, which defines exceptions that are not expected to be
caught under normal circumstances by your program. Exceptions of type Error are used by
the Java run-time system to indicate errors having to do with the run-time environment, itself.
Stack overflow is an example of such an error. This chapter will not be dealing with exceptions
of type Error, because these are typically created in response to catastrophic failures that
cannot usually be handled by your program.
Uncaught Exceptions
Before you learn how to handle exceptions in your program, it is useful to see what happens
when you don’t handle them. This small program includes an expression that intentionally
causes a divide-by-zero error:
class Exc0 {
public static void main(String args[]) {
int d = 0;

int a = 42 / d;
}
}
When the Java run-time system detects the attempt to divide by zero, it constructs a new
exception object and then throws this exception. This causes the execution of Exc0 to stop,
because once an exception has been thrown, it must be caught by an exception handler and
dealt with immediately. In this example, we haven’t supplied any exception handlers of our
own, so the exception is caught by the default handler provided by the Java run-time system.
Any exception that is not caught by your program will ultimately be processed by the default
handler. The default handler displays a string describing the exception, prints a stack trace from
the point at which the exception occurred, and terminates the program.
Here is the exception generated when this example is executed:
java.lang.ArithmeticException: / by zero
at Exc0.main(Exc0.java:4)
Notice how the class name, Exc0; the method name, main; the filename, Exc0.java; and the
line number, 4, are all included in the simple stack trace. Also, notice that the type of exception
thrown is a subclass of Exception called ArithmeticException, which more specifically
describes what type of error happened. As discussed later in this chapter, Java supplies several
built-in exception types that match the various sorts of run-time errors that can be generated.
The stack trace will always show the sequence of method invocations that led up to the error.
For example, here is another version of the preceding program that introduces the same error
but in a method separate from main( ):
class Exc1 {
static void subroutine() {
int d = 0;
int a = 10 / d;
}
Exc1.subroutine();
}
}
The resulting stack trace from the default exception handler shows how the entire call stack is
displayed:
java.lang.ArithmeticException: / by zero

at Exc1.subroutine(Exc1.java:4)
at Exc1.main(Exc1.java:7)
As you can see, the bottom of the stack is main’s line 7, which is the call to subroutine( ),
which caused the exception at line 4. The call stack is quite useful for debugging, because it
pinpoints the precise sequence of steps that led to the error.
Using try and catch
Although the default exception handler provided by the Java run-time system is useful for
debugging, you will usually want to handle an exception yourself. Doing so provides two
benefits. First, it allows you to fix the error. Second, it prevents the program from automatically
terminating. Most users would be confused (to say the least) if your program stopped running
and printed a stack trace whenever an error occurred! Fortunately, it is quite easy to prevent
this.
To guard against and handle a run-time error, simply enclose the code that you want to monitor
inside a try block. Immediately following the try block, include a catch clause that specifies
the exception type that you wish to catch. To illustrate how easily this can be done, the
following program includes a try block and a catch clause that processes the
ArithmeticException generated by the division-by-zero error:
class Exc2 {
int d, a;
try { // monitor a block of code.
d = 0;
a = 42 / d;
System.out.println("This will not be printed.");
} catch (ArithmeticException e) { // catch divide-by-zero error
System.out.println("Division by zero.");
}
System.out.println("After catch statement.");
}
}
This program generates the following output:
Division by zero.

After catch statement.
A try and its catch statement form a unit. The scope of the catch clause is restricted to those
statements specified by the immediately preceding try statement. A catch statement cannot
catch an exception thrown by another try statement (except in the case of nested try statements,
described shortly). The statements that are protected by try must be surrounded by curly braces.
(That is, they must be within a block.) You cannot use try on a single statement.
The goal of most well-constructed catch clauses should be to resolve the exceptional condition
and then continue on as if the error had never happened. For example, in the next program each
iteration of the for loop obtains two random integers. Those two integers are divided by each
other, and the result is used to divide the value 12345. The final result is put into a. If either
division operation causes a divide-by-zero error, it is caught, the value of a is set to zero, and
the program continues.
// Handle an exception and move on.
import java.util.Random;
class HandleError {
int a=0, b=0, c=0;
Random r = new Random();
for(int i=0; i<32000; i++) {
try {
b = r.nextInt();
c = r.nextInt();
a = 12345 / (b/c);
} catch (ArithmeticException e) {
System.out.println("Division by zero.");
a = 0; // set a to zero and continue
}
System.out.println("a: " + a);
}
}
}

Displaying a Description of an Exception
Throwable overrides the toString( ) method (defined by Object) so that it returns a string
containing a description of the exception. You can display this description in a println( )
statement by simply passing the exception as an argument. For example, the catch block
in the preceding program can be rewritten like this:
catch (ArithmeticException e) {
System.out.println("Exception: " + e);
a = 0; // set a to zero and continue
}
When this version is substituted in the program, and the program is run, each divide-byzero
error displays the following message:
Exception: java.lang.ArithmeticException: / by zero
While it is of no particular value in this context, the ability to display a description of an
exception is valuable in other circumstances—particularly when you are experimenting with
exceptions or when you are debugging.
Multiple catch Clauses
In some cases, more than one exception could be raised by a single piece of code. To handle
this type of situation, you can specify two or more catch clauses, each catching a different type
of exception. When an exception is thrown, each catch statement is inspected in order, and the
first one whose type matches that of the exception is executed. After one catch statement
executes, the others are bypassed, and execution continues after the try/catch block. The
following example traps two different exception types:
// Demonstrate multiple catch statements.
class MultiCatch {
try {
int a = args.length;
System.out.println("a = " + a);
int b = 42 / a;
int c[] = { 1 };
c[42] = 99;

} catch(ArithmeticException e) {
System.out.println("Divide by 0: " + e);
} catch(ArrayIndexOutOfBoundsException e) {
System.out.println("Array index oob: " + e);
}
System.out.println("After try/catch blocks.");
}
}
This program will cause a division-by-zero exception if it is started with no command line
arguments, since a will equal zero. It will survive the division if you provide a command-line
argument, setting a to something larger than zero. But it will cause an
ArrayIndexOutOfBoundsException, since the int array c has a length of 1, yet the program
attempts to assign a value to c[42].
Here is the output generated by running it both ways:
C:>java MultiCatch
a = 0
Divide by 0: java.lang.ArithmeticException: / by zero
After try/catch blocks.
C:>java MultiCatch TestArg
a = 1
Array index oob: java.lang.ArrayIndexOutOfBoundsException:42
After try/catch blocks.
Nested try Statements
The try statement can be nested. That is, a try statement can be inside the block of another try.
Each time a try statement is entered, the context of that exception is pushed on the stack. If an
inner try statement does not have a catch handler for a particular exception, the stack is
unwound and the next try statement’s catch handlers are inspected for a match. This continues
until one of the catch statements succeeds, or until all of the nested try statements are
exhausted.
If no catch statement matches, then the Java run-time system will handle the exception. Here

is an example that uses nested try statements:
// An example of nested try statements.
class NestTry {
try {
int a = args.length;
/* If no command-line args are present, the following statement will generate a divide-by-zero
exception. */
int b = 42 / a;
System.out.println("a = " + a);
try { // nested try block
/* If one command-line arg is used, then a divide-by-zero exception will be generated by the
following code. */
if(a==1) a = a/(a-a); // division by zero
/* If two command-line args are used, then generate an out-of-bounds exception. */
if(a==2) {
int c[] = { 1 };
} catch(ArrayIndexOutOfBoundsException e) {
System.out.println("Array index out-of-bounds: " + e);
}
} catch(ArithmeticException e) {
System.out.println("Divide by 0: " + e);
}
}
}
As you can see, this program nests one try block within another. The program works as follows.
When you execute the program with no command-line arguments, a divide-by-zero exception
is generated by the outer try block. Execution of the program with one command-line argument
generates a divide-by-zero exception from within the nested try block. Since the inner block
does not catch this exception, it is passed on to the outer try block, where it is handled. If you
execute the program with two command-line arguments, an array boundary exception is
generated from within the inner try block.

throw
So far, you have only been catching exceptions that are thrown by the Java run-time system.
However, it is possible for your program to throw an exception explicitly, using the throw
statement. The general form of throw is shown here:
throw ThrowableInstance;
Here, ThrowableInstance must be an object of type Throwable or a subclass of Throwable.
Primitive types, such as int or char, as well as non-Throwable classes, such as String and
Object, cannot be used as exceptions. There are two ways you can obtain a Throwable object:
using a parameter in a catch clause, or creating one with the new operator.
The flow of execution stops immediately after the throw statement; any subsequent statements
are not executed. The nearest enclosing try block is inspected to see if it has a catch statement
that matches the type of exception. If it does find a match, control is transferred to that
statement. If not, then the next enclosing try statement is inspected, and so on. If no matching
catch is found, then the default exception handler halts the program and prints the stack trace.
the exception rethrows it to the outer handler.
// Demonstrate throw.
class ThrowDemo {
static void demoproc() {
try {
throw new NullPointerException("demo");
} catch(NullPointerException e) {
System.out.println("Caught inside demoproc.");
throw e; // rethrow the exception
}
}
try {
demoproc();
System.out.println("Recaught: " + e);
}
}

}
This program gets two chances to deal with the same error. First, main( ) sets up an exception
context and then calls demoproc( ). The demoproc( ) method then sets up another exception
handling context and immediately throws a new instance of NullPointerException, which
is caught on the next line. The exception is then rethrown. Here is the resulting output:
Caught inside demoproc.
Recaught: java.lang.NullPointerException: demo
throws
If a method is capable of causing an exception that it does not handle, it must specify this
behavior so that callers of the method can guard themselves against that exception. You do this
by including a throws clause in the method’s declaration. Athrows clause lists the types of
exceptions that a method might throw. This is necessary for all exceptions, except those of type
Error or RuntimeException, or any of their subclasses. All other exceptions that a method
can throw must be declared in the throws clause. If they are not, a compile-time error will
result.
This is the general form of a method declaration that includes a throws clause:
type method-name(parameter-list) throws exception-list
{
// body of method
}
Here, exception-list is a comma-separated list of the exceptions that a method can throw.
Following is an example of an incorrect program that tries to throw an exception that it does
not catch. Because the program does not specify a throws clause to declare this fact, the
program will not compile.
// This program contains an error and will not compile.
class ThrowsDemo {
static void throwOne() {
System.out.println("Inside throwOne.");
throw new IllegalAccessException("demo");
}
throwOne();

}
}
To make this example compile, you need to make two changes. First, you need to declare that
throwOne( ) throws IllegalAccessException. Second, main( ) must define a try/catch
statement that catches this exception.
finally
When exceptions are thrown, execution in a method takes a rather abrupt, nonlinear path that
alters the normal flow through the method. Depending upon how the method is coded, it is
even possible for an exception to cause the method to return prematurely. This could be a
problem in some methods. For example, if a method opens a file upon entry and closes it upon
exit, then you will not want the code that closes the file to be bypassed by the exception-
handling mechanism. The finally keyword is designed to address this contingency.
finally creates a block of code that will be executed after a try/catch block has completed and
before the code following the try/catch block. The finally block will execute whether or not
an exception is thrown. If an exception is thrown, the finally block will execute even if no
catch statement matches the exception. Any time a method is about to return to the caller from
inside a try/catch block, via an uncaught exception or an explicit return statement, the finally
clause is also executed just before the method returns. This can be useful for closing file handles
and freeing up any other resources that might have been allocated at the beginning of a method
with the intent of disposing of them before returning. The finally clause is optional. However,
each try statement requires at least one catch or a finally clause.
Here is an example program that shows three methods that exit in various ways, none without
executing their finally clauses:
// Demonstrate finally.
class FinallyDemo {
// Through an exception out of the method.
static void procA() {
try {
System.out.println("inside procA");
throw new RuntimeException("demo");
} finally {
System.out.println("procA's finally");

}
}
// Return from within a try block.
static void procB() {
try {
System.out.println("inside procB");
return;
} finally {
System.out.println("procB's finally");
}
}
// Execute a try block normally.
static void procC() {
try {
System.out.println("inside procC");
} finally {
System.out.println("procC's finally");
}
}
try {
procA();
} catch (Exception e) {
System.out.println("Exception caught");
}
procB();
procC();
}
}
In this example, procA( ) prematurely breaks out of the try by throwing an exception.
The finally clause is executed on the way out. procB( )’s try statement is exited via a return
statement. The finally clause is executed before procB( ) returns. In procC( ), the try statement
executes normally, without error. However, the finally block is still executed.

Java’s Built-in Exceptions
Inside the standard package java.lang, Java defines several exception classes. A few have
been used by the preceding examples. The most general of these exceptions are subclasses
of the standard type RuntimeException. As previously explained, these exceptions need
not be included in any method’s throws list.

Creating Your Own Exception Subclasses
Although Java’s built-in exceptions handle most common errors, you will probably want to
create your own exception types to handle situations specific to your applications. This is quite
easy to do: just define a subclass of Exception (which is, of course, a subclass of Throwable).
Your subclasses don’t need to actually implement anything—it is their existence in the type
system that allows you to use them as exceptions.
The Exception class does not define any methods of its own. It does, of course, inherit those
methods provided by Throwable. Thus, all exceptions, including those that you create, have
the methods defined by Throwable available to them. They are shown in Table 10-3.
Exception defines four constructors. Two were added by JDK 1.4 to support chained
exceptions, described in the next section. The other two are shown here:

Exception( )
Exception(String msg)
The first form creates an exception that has no description. The second form lets you specify a
description of the exception.
The following example declares a new subclass of Exception and then uses that subclass to
signal an error condition in a method. It overrides the toString( ) method, allowing a carefully
tailored description of the exception to be displayed.
// This program creates a custom exception type.
class MyException extends Exception {
private int detail;
MyException(int a) {
detail = a;
}
public String toString() {
return "MyException[" + detail + "]";
}
}
class ExceptionDemo {
static void compute(int a) throws MyException {
System.out.println("Called compute(" + a + ")");
if(a > 10)
throw new MyException(a);
System.out.println("Normal exit");
}
try {
compute(1);
compute(20);
} catch (MyException e) {
System.out.println("Caught " + e);
}
}

}
This example defines a subclass of Exception called MyException. This subclass is quite
simple: it has only a constructor plus an overloaded toString( ) method that displays the value
of the exception. The ExceptionDemo class defines a method named compute( ) that throws
a MyException object. The exception is thrown when compute( )’s integer parameter is
greater than 10. The main( ) method sets up an exception handler for MyException, then calls
compute( ) with a legal value (less than 10) and an illegal one to show both paths through the
code. Here is the result:
Called compute(1)
Normal exit
Called compute(20)
Caught MyException[20]
Chained Exceptions
Beginning with JDK 1.4, a new feature has been incorporated into the exception subsystem:
chained exceptions. The chained exception feature allows you to associate another exception
with an exception. This second exception describes the cause of the first exception. For
example, imagine a situation in which a method throws an ArithmeticException because of
an attempt to divide by zero. However, the actual cause of the problem was that an I/O error
occurred, which caused the divisor to be set improperly. Although the method must certainly
throw an ArithmeticException, since that is the error that occurred, you might also want to let
the calling code know that the underlying cause was an I/O error. Chained exceptions let you
handle this, and any other situation in which layers of exceptions exist.
To allow chained exceptions, two constructors and two methods were added to Throwable.
The constructors are shown here:
Throwable(Throwable causeExc)
Throwable(String msg, Throwable causeExc)
In the first form, causeExc is the exception that causes the current exception. That is, causeExc
is the underlying reason that an exception occurred. The second form allows you to specify a
description at the same time that you specify a cause exception. These two constructors have
also been added to the Error, Exception, and RuntimeException classes.
The chained exception methods added to Throwable are getCause( ) and initCause( ). These
methods are shown in Table 10-3 and are repeated here for the sake of discussion.

Throwable getCause( )
Throwable initCause(Throwable causeExc)
The getCause( ) method returns the exception that underlies the current exception. If there is
no underlying exception, null is returned. The initCause( ) method associates causeExc with
the invoking exception and returns a reference to the exception. Thus, you can associate a cause
with an exception after the exception has been created. However, the cause exception can be
set only once. Thus, you can call initCause( ) only once for each exception object.
Furthermore, if the cause exception was set by a constructor, then you can’t set it again using
initCause( ). In general, initCause( ) is used to set a cause for legacy exception classes that
don’t support the two additional constructors described earlier.
Here is an example that illustrates the mechanics of handling chained exceptions:
// Demonstrate exception chaining.
class ChainExcDemo {
static void demoproc() {
// create an exception
NullPointerException e =
new NullPointerException("top layer");
// add a cause
e.initCause(new ArithmeticException("cause"));
throw e;
}
try {
demoproc();
// display top level exception
System.out.println("Caught: " + e);
// display cause exception
System.out.println("Original cause: " +
e.getCause());
}
}
}

The output from the program is shown here:
Caught: java.lang.NullPointerException: top layer
Original cause: java.lang.ArithmeticException: cause
Using Exceptions
Exception handling provides a powerful mechanism for controlling complex programs that
have many dynamic run-time characteristics. It is important to think of try, throw, and catch
as clean ways to handle errors and unusual boundary conditions in your program’s logic. Unlike
some other languages in which error return codes are used to indicate failure, Java uses
exceptions. Thus, when a method can fail, have it throw an exception. This is a cleaner way to
handle failure modes.
One last point: Java’s exception-handling statements should not be considered a general
mechanism for nonlocal branching. If you do so, it will only confuse your code and make it
hard to maintain.
Multithreaded Programming
Java provides built-in support for multithreaded programming. A multithreaded program
contains two or more parts that can run concurrently. Each part of such a program is called a
thread, and each thread defines a separate path of execution. Thus, multithreading is a
specialized form of multitasking. In a thread-based multitasking environment, the thread is the
smallest unit of dispatchable code. This means that a single program can perform two or more
tasks simultaneously. For instance, a text editor can format text at the same time that it is
printing, as long as these two actions are being performed by two separate threads. Thus,
process-based multitasking deals with the “big picture,” and thread-based multitasking handles
the details.
Multitasking threads require less overhead than multitasking processes. Processes are
heavyweight tasks that require their own separate address spaces. Interprocess communication
is expensive and limited. Context switching from one process to another is also costly. Threads,
on the other hand, are lightweight. They share the same address space and cooperatively share
the same heavyweight process. Interthread communication is inexpensive, and context
switching from one thread to the next is low cost. While Java programs make use of process
based multitasking environments, process-based multitasking is not under the control of Java.

The Java Thread Model
The Java run-time system depends on threads for many things, and all the class libraries are
designed with multithreading in mind. In fact, Java uses threads to enable the entire
environment to be asynchronous. This helps reduce inefficiency by preventing the waste of
CPU cycles.
The value of a multithreaded environment is best understood in contrast to its counterpart.
Single-threaded systems use an approach called an event loop with polling. In this model, a
single thread of control runs in an infinite loop, polling a single event queue to decide what to
do next. Once this polling mechanism returns with, say, a signal that a network file is ready to
be read, then the event loop dispatches control to the appropriate event handler.
Until this event handler returns, nothing else can happen in the system. This wastes CPU time.
It can also result in one part of a program dominating the system and preventing any other
events from being processed. In general, in a singled-threaded environment, when a thread
blocks (that is, suspends execution) because it is waiting for some resource, the entire program
stops running.
The benefit of Java’s multithreading is that the main loop/polling mechanism is eliminated.
One thread can pause without stopping other parts of your program. For example, the idle time
created when a thread reads data from a network or waits for user input can be utilized
elsewhere. Multithreading allows animation loops to sleep for a second between each frame
without causing the whole system to pause. When a thread blocks in a Java program, only the
single thread that is blocked pauses. All other threads continue to run.
Threads exist in several states. A thread can be running. It can be ready to run as soon as it
gets CPU time. Arunning thread can be suspended, which temporarily suspends its activity.
A suspended thread can then be resumed, allowing it to pick up where it left off. A thread can
be blocked when waiting for a resource. At any time, a thread can be terminated, which halts
its execution immediately. Once terminated, a thread cannot be resumed.
Thread Priorities
Java assigns to each thread a priority that determines how that thread should be treated with
respect to the others. Thread priorities are integers that specify the relative priority of one thread
to another. As an absolute value, a priority is meaningless; a higher-priority thread doesn’t run
any faster than a lower-priority thread if it is the only thread running.

Instead, a thread’s priority is used to decide when to switch from one running thread to the
next. This is called a context switch. The rules that determine when a context switch takes place
are simple:
• A thread can voluntarily relinquish control. This is done by explicitly yielding, sleeping, or
blocking on pending I/O. In this scenario, all other threads are examined, and the highest-
priority thread that is ready to run is given the CPU.
• A thread can be preempted by a higher-priority thread. In this case, a lower-priority thread
that does not yield the processor is simply preempted—no matter what it is doing— by a higher-
priority thread. Basically, as soon as a higher-priority thread wants to run, it does. This is called
preemptive multitasking.
Synchronization
Because multithreading introduces an asynchronous behavior to your programs, there must be
a way for you to enforce synchronicity when you need it. For example, if you want two threads
to communicate and share a complicated data structure, such as a linked list, you need some
way to ensure that they don’t conflict with each other. That is, you must prevent one thread
from writing data while another thread is in the middle of reading it. For this purpose, Java
implements an elegant twist on an age-old model of interprocess synchronization: the monitor.
The monitor is a control mechanism first defined by C.A.R. Hoare. You can think of a monitor
as a very small box that can hold only one thread. Once a thread enters a monitor, all other
threads must wait until that thread exits the monitor. In this way, a monitor can be used to
protect a shared asset from being manipulated by more than one thread at a time.
Most multithreaded systems expose monitors as objects that your program must explicitly
acquire and manipulate. Java provides a cleaner solution. There is no class “Monitor”; instead,
each object has its own implicit monitor that is automatically entered when one of the object’s
synchronized methods is called. Once a thread is inside a synchronized method, no other thread
can call any other synchronized method on the same object. This enables you to write very
clear and concise multithreaded code, because synchronization support is built into the
language.
Messaging
After you divide your program into separate threads, you need to define how they will
communicate with each other. When programming with most other languages, you must

depend on the operating system to establish communication between threads. This, of course,
adds overhead. By contrast, Java provides a clean, low-cost way for two or more threads to talk
to each other, via calls to predefined methods that all objects have. Java’s messaging system
allows a thread to enter a synchronized method on an object, and then wait there until some
other thread explicitly notifies it to come out.
The Thread Class and the Runnable Interface
Java’s multithreading system is built upon the Thread class, its methods, and its companion
interface, Runnable. Thread encapsulates a thread of execution. Since you can’t directly refer
to the ethereal state of a running thread, you will deal with it through its proxy, the Thread
instance that spawned it. To create a new thread, your program will either extend Thread or
implement the Runnable interface.
The Thread class defines several methods that help manage threads. The ones that will be used
in this chapter are shown here:
The Main Thread
When a Java program starts up, one thread begins running immediately. This is usually called
the main thread of your program, because it is the one that is executed when your program
begins. The main thread is important for two reasons:
• It is the thread from which other “child” threads will be spawned.
• Often, it must be the last thread to finish execution because it performs various shutdown
actions.
Although the main thread is created automatically when your program is started, it can be
controlled through a Thread object. To do so, you must obtain a reference to it by calling the

method currentThread( ), which is a public static member of Thread. Its general form is
shown here:
static Thread currentThread( )
This method returns a reference to the thread in which it is called. Once you have a reference
to the main thread, you can control it just like any other thread.
Let’s begin by reviewing the following example:
// Controlling the main Thread.
class CurrentThreadDemo {
Thread t = Thread.currentThread();
System.out.println("Current thread: " + t);
// change the name of the thread
t.setName("My Thread");
System.out.println("After name change: " + t);
try {
for(int n = 5; n > 0; n--) {
System.out.println(n);
Thread.sleep(1000);
}
} catch (InterruptedException e) {
System.out.println("Main thread interrupted");
}
}
}
In this program, a reference to the current thread (the main thread, in this case) is obtained by
calling currentThread( ), and this reference is stored in the local variable t. Next, the program
displays information about the thread. The program then calls setName( ) to change the internal
name of the thread. Information about the thread is then redisplayed. Next, a loop counts down
from five, pausing one second between each line. The pause is accomplished by the sleep( )
method. The argument to sleep( ) specifies the delay period in milliseconds.
Notice the try/catch block around this loop. The sleep( ) method in Thread might throw an
InterruptedException. This would happen if some other thread wanted to interrupt this

sleeping one. This example just prints a message if it gets interrupted. In a real program, you
would need to handle this differently. Here is the output generated by this program:
Current thread: Thread[main,5,main]
After name change: Thread[My Thread,5,main]
5
4
3
2
1
Creating a Thread
In the most general sense, you create a thread by instantiating an object of type Thread. Java
defines two ways in which this can be accomplished:
• You can implement the Runnable interface.
• You can extend the Thread class, itself.
The following two sections look at each method, in turn.
Implementing Runnable
The easiest way to create a thread is to create a class that implements the Runnable interface.
Runnable abstracts a unit of executable code. You can construct a thread on any object that
implements Runnable. To implement Runnable, a class need only implement a single method
called run( ), which is declared like this:
public void run( )
Inside run( ), you will define the code that constitutes the new thread. It is important to
understand that run( ) can call other methods, use other classes, and declare variables, just like
the main thread can. The only difference is that run( ) establishes the entry point for another,
concurrent thread of execution within your program. This thread will end when run( ) returns.
After you create a class that implements Runnable, you will instantiate an object of type
Thread from within that class. Thread defines several constructors. The one that we will use
is shown here:
Thread(Runnable threadOb, String threadName)
In this constructor, threadOb is an instance of a class that implements the Runnable interface.
This defines where execution of the thread will begin. The name of the new thread is specified
by threadName.

After the new thread is created, it will not start running until you call its start( ) method, which
is declared within Thread. In essence, start( ) executes a call to run( ). The start( ) method is
shown here:
void start( )
Here is an example that creates a new thread and starts it running:
// Create a second thread.
class NewThread implements Runnable {
Thread t;
NewThread() {
// Create a new, second thread
t = new Thread(this, "Demo Thread");
System.out.println("Child thread: " + t);
t.start(); // Start the thread
}
// This is the entry point for the second thread.
public void run() {
try {
for(int i = 5; i > 0; i--) {
System.out.println("Child Thread: " + i);
Thread.sleep(500);
}
System.out.println("Child interrupted.");
}
System.out.println("Exiting child thread.");
}
}
class ThreadDemo {
new NewThread(); // create a new thread
try {
for(int i = 5; i > 0; i--) {
System.out.println("Main Thread: " + i);
Thread.sleep(1000);

}
System.out.println("Main thread interrupted.");
}
System.out.println("Main thread exiting.");
}
}
Inside NewThread’s constructor, a new Thread object is created by the following statement:
t = new Thread(this, "Demo Thread");
Passing this as the first argument indicates that you want the new thread to call the run( )
method on this object. Next, start( ) is called, which starts the thread of execution beginning
at the run( ) method. This causes the child thread’s for loop to begin. After calling start( ),
NewThread’s constructor returns to main( ). When the main thread resumes, it enters its for
loop. Both threads continue running, sharing the CPU, until their loops finish. The output
produced by this program is as follows. (Your output may vary based on processor speed and
task load.)
Child thread: Thread[Demo Thread,5,main]
Main Thread: 5
Child Thread: 5
Child Thread: 4
Main Thread: 4
Child Thread: 3
Child Thread: 2
Main Thread: 3
Child Thread: 1
Exiting child thread.
Main Thread: 2
Main Thread: 1
Main thread exiting.

Extending Thread
The second way to create a thread is to create a new class that extends Thread, and then to
create an instance of that class. The extending class must override the run( ) method, which is
the entry point for the new thread. It must also call start( ) to begin execution of the new thread.
Here is the preceding program rewritten to extend Thread:
// Create a second thread by extending Thread
class NewThread extends Thread {
NewThread() {
// Create a new, second thread
super("Demo Thread");
System.out.println("Child thread: " + this);
start(); // Start the thread
}
// This is the entry point for the second thread.
public void run() {
try {
for(int i = 5; i > 0; i--) {
System.out.println("Child Thread: " + i);
Thread.sleep(500);
}
System.out.println("Child interrupted.");
}
System.out.println("Exiting child thread.");
}
}
class ExtendThread {
new NewThread(); // create a new thread
try {
for(int i = 5; i > 0; i--) {
System.out.println("Main Thread: " + i);
Thread.sleep(1000);

}
}
}
}
This program generates the same output as the preceding version. As you can see, the child
thread is created by instantiating an object of NewThread, which is derived from Thread.
Notice the call to super( ) inside NewThread. This invokes the following form of the Thread
constructor:
public Thread(String threadName)
Here, threadName specifies the name of the thread.
Choosing an Approach
At this point, you might be wondering why Java has two ways to create child threads, and
which approach is better. The answers to these questions turn on the same point. The Thread
class defines several methods that can be overridden by a derived class. Of these methods, the
only one that must be overridden is run( ). This is, of course, the same method required when
you implement Runnable. Many Java programmers feel that classes should be extended only
when they are being enhanced or modified in some way. So, if you will not be overriding any
of Thread’s other methods, it is probably best simply to implement Runnable. This is up to
you, of course. However, throughout the rest of this chapter, we will create threads by using
classes that implement Runnable.
Creating Multiple Threads
So far, you have been using only two threads: the main thread and one child thread. However,
your program can spawn as many threads as it needs. For example, the following program
creates three child threads:
// Create multiple threads.
String name; // name of thread

Thread t;
NewThread(String threadname) {
name = threadname;
t = new Thread(this, name);
System.out.println("New thread: " + t);
}
// This is the entry point for thread.
public void run() {
try {
for(int i = 5; i > 0; i--) {
System.out.println(name + ": " + i);
Thread.sleep(1000);
}
System.out.println(name + "Interrupted");
}
System.out.println(name + " exiting.");
}
}
class MultiThreadDemo {
new NewThread("One"); // start threads
new NewThread("Two");
new NewThread("Three");
try {
// wait for other threads to end
Thread.sleep(10000);
System.out.println("Main thread Interrupted");
}
}

}
The output from this program is shown here:
New thread: Thread[One,5,main]
New thread: Thread[Two,5,main]
New thread: Thread[Three,5,main]
One: 5
Two: 5
Three: 5
One: 4
Two: 4
Three: 4
One: 3
Three: 3
Two: 3
One: 2
Three: 2
Two: 2
One: 1
Three: 1
Two: 1
One exiting.
Two exiting.
Three exiting.
As you can see, once started, all three child threads share the CPU. Notice the call to
sleep(10000) in main( ). This causes the main thread to sleep for ten seconds and ensures that
it will finish last.
Using isAlive( ) and join( )
As mentioned, often you will want the main thread to finish last. In the preceding examples,
this is accomplished by calling sleep( ) within main( ), with a long enough delay to ensure that
all child threads terminate prior to the main thread. However, this is hardly a satisfactory

solution, and it also raises a larger question: How can one thread know when another thread
has ended? Fortunately, Thread provides a means by which you can answer this question.
Two ways exist to determine whether a thread has finished. First, you can call isAlive( ) on the
thread. This method is defined by Thread, and its general form is shown here:
final boolean isAlive( )
The isAlive( ) method returns true if the thread upon which it is called is still running. It returns
false otherwise.
While isAlive( ) is occasionally useful, the method that you will more commonly use to wait
for a thread to finish is called join( ), shown here:
final void join( ) throws InterruptedException
This method waits until the thread on which it is called terminates. Its name comes from the
concept of the calling thread waiting until the specified thread joins it. Additional forms of
join( ) allow you to specify a maximum amount of time that you want to wait for the specified
thread to terminate.
Here is an improved version of the preceding example that uses join( ) to ensure that the main
thread is the last to stop. It also demonstrates the isAlive( ) method.
// Using join() to wait for threads to finish.
String name; // name of thread
Thread t;
NewThread(String threadname) {
name = threadname;
t = new Thread(this, name);
System.out.println("New thread: " + t);
}
// This is the entry point for thread.
public void run() {
try {
for(int i = 5; i > 0; i--) {
System.out.println(name + ": " + i);
Thread.sleep(1000);
}

System.out.println(name + " interrupted.");
}
System.out.println(name + " exiting.");
}
}
class DemoJoin {
NewThread ob1 = new NewThread("One");
NewThread ob2 = new NewThread("Two");
NewThread ob3 = new NewThread("Three");
System.out.println("Thread One is alive: "
+ ob1.t.isAlive());
System.out.println("Thread Two is alive: "
+ ob2.t.isAlive());
System.out.println("Thread Three is alive: "
+ ob3.t.isAlive());
// wait for threads to finish
try {
System.out.println("Waiting for threads to finish.");
ob1.t.join();
ob2.t.join();
ob3.t.join();
System.out.println("Main thread Interrupted");
}
System.out.println("Thread One is alive: "
+ ob1.t.isAlive());
System.out.println("Thread Two is alive: "
+ ob2.t.isAlive());
System.out.println("Thread Three is alive: "
+ ob3.t.isAlive());
}

}
Sample output from this program is shown here. (Your output may vary based on processor
speed and task load.)
New thread: Thread[One,5,main]
New thread: Thread[Two,5,main]
New thread: Thread[Three,5,main]
Thread One is alive: true
Thread Two is alive: true
Thread Three is alive: true
Waiting for threads to finish.
One: 5
Two: 5
Three: 5
One: 4
Two: 4
Three: 4
One: 3
Two: 3
Three: 3
One: 2
Two: 2
Three: 2
One: 1
Two: 1
Three: 1
Two exiting.
Three exiting.
One exiting.
Thread One is alive: false
Thread Two is alive: false
Thread Three is alive: false
As you can see, after the calls to join( ) return, the threads have stopped executing.

Thread Priorities
Thread priorities are used by the thread scheduler to decide when each thread should be allowed
to run. In theory, higher-priority threads get more CPU time than lower-priority threads. In
practice, the amount of CPU time that a thread gets often depends on several factors besides its
priority. (For example, how an operating system implements multitasking can affect the
relative availability of CPU time.) A higher-priority thread can also preempt a lower-priority
one. For instance, when a lower-priority thread is running and a higher-priority thread resumes
(from sleeping or waiting on I/O, for example), it will preempt the lowerpriority thread.
In theory, threads of equal priority should get equal access to the CPU. But you need to be
careful. Remember, Java is designed to work in a wide range of environments. Some of those
environments implement multitasking fundamentally differently than others. For safety,
threads that share the same priority should yield control once in a while. This ensures that all
threads have a chance to run under a nonpreemptive operating system. In practice, even in
nonpreemptive environments, most threads still get a chance to run, because most threads
inevitably encounter some blocking situation, such as waiting for I/O. When this happens, the
blocked thread is suspended and other threads can run. But, if you want smooth multithreaded
execution, you are better off not relying on this. Also, some types of tasks are CPU-intensive.
Such threads dominate the CPU. For these types of threads, you want to yield control
occasionally so that other threads can run.
To set a thread’s priority, use the setPriority( ) method, which is a member of Thread.
This is its general form:
final void setPriority(int level)
Here, level specifies the new priority setting for the calling thread. The value of level must be
within the range MIN_PRIORITY and MAX_PRIORITY. Currently, these values are 1 and
10, respectively. To return a thread to default priority, specify NORM_PRIORITY, which is
currently 5. These priorities are defined as static final variables within Thread.
You can obtain the current priority setting by calling the getPriority( ) method of Thread,
shown here:
final int getPriority( )

The following example demonstrates two threads at different priorities, which do not run on a
preemptive platform in the same way as they run on a nonpreemptive platform.
One thread is set two levels above the normal priority, as defined by Thread.NORM_
PRIORITY, and the other is set to two levels below it. The threads are started and allowed to
run for ten seconds. Each thread executes a loop, counting the number of iterations. After ten
seconds, the main thread stops both threads. The number of times that each thread made it
through the loop is then displayed.
// Demonstrate thread priorities.
class clicker implements Runnable {
long click = 0;
Thread t;
private volatile boolean running = true;
public clicker(int p) {
t = new Thread(this);
t.setPriority(p);
}
public void run() {
while (running) {
click++;
}
}
public void stop() {
running = false;
}
public void start() {
t.start();
}
}
class HiLoPri {
Thread.currentThread().setPriority(Thread.MAX_PRIORITY);
clicker hi = new clicker(Thread.NORM_PRIORITY + 2);
clicker lo = new clicker(Thread.NORM_PRIORITY - 2);
lo.start();

hi.start();
try {
Thread.sleep(10000);
}
o.stop();
hi.stop();
// Wait for child threads to terminate.
try {
hi.t.join();
lo.t.join();
System.out.println("InterruptedException caught");
}
System.out.println("Low-priority thread: " + lo.click);
System.out.println("High-priority thread: " + hi.click);
}
}
The output of this program, shown as follows when run under Windows, indicates that the
threads did context switch, even though neither voluntarily yielded the CPU nor blocked for
I/O. The higher-priority thread got the majority of the CPU time.
Low-priority thread: 4408112
High-priority thread: 589626904

MODULE5_EXCEPTION HANDLING.docx

More Related Content

Similar to MODULE5_EXCEPTION HANDLING.docx (20)

More from VeerannaKotagi1 (8)

Recently uploaded (20)

MODULE5_EXCEPTION HANDLING.docx