Exception Handling
Exception Handling
Exception Handling
An exception is a problem that arises during the execution of a program. An exception can
occur for many different reasons, including the following:
A user has entered invalid data.
A file that needs to be opened cannot be found.
A network connection has been lost in the middle of communications, or the JVM has run out
of memory
“Exceptional Handling is a task to maintain normal flow of the program. For this we
should try to catch the exception object thrown by the error condition and then
display appropriate message for taking corrective actions”
Types of Exceptions
All exception classes are subtypes of the java.lang.Exception class. The exception class is a
subclass of the Throwable class. Other than the exception class there is another subclass called
Error which is derived from the Throwable class.
Table of JAVA – Built in Exceptions
Exception Description
ArithmeticException Arithmetic error, such as divide-by-zero.
ArrayIndexOutOfBoundsExceptio Array index is out-of-bounds.
n
ArrayStoreException Assignment to an array element of an incompatible
type.
try
catch
finally
throw
throws
A method catches an exception using a combination of the try and catch keywords. A try/catch block
is placed around the code that might generate an exception. Code within a try/catch block is referred
to as protected code, and the syntax for using try/catch looks like the following:
A catch statement involves declaring the type of exception you are trying to catch. If an exception
occurs in protected code, the catch block (or blocks) that follows the try is checked. If the type of
exception that occurred is listed in a catch block, the exception is passed to the catch block much as an
argument is passed into a method parameter.
Output:
Output
Multiple Catch Blocks:
A try block can be followed by multiple catch blocks, but when we use multiple catch statements
it is important that exception subclasses must come before any of their superclasses. The reason
is “a catch statement with superclass will catch exceptions of that type plus any of its subclass,
thus causing a catch statement with subclass exception a non- reachable code which is error in
JAVA”.
Example:
Output
However if the order of the catch blocks is reversed like shown below, then program will execute
normally
Finally Block
The finally keyword is used to create a block of code that follows a try block. A finally block of
code always executes, whether or not an exception has occurred. Using a finally block allows
you to run any cleanup-type statements that you want to execute, no matter what happens in
the protected code.
In the first case no command line arguments are passed which will throw
ArrayIndexOutOfBoundsException and in the above code we are handling only
ArithmeticException which will cause the system to terminate and remaining program will not
run. But in this case also the statement written in the finally block will gets executed as shown
below:
In second case ‘0’ is passed as command line argument to let program throw
ArithmeticException which will eventually be handled by catch block. See the output below
which clearly shows that remaining part of the code will also run along with finally statement.
In third case ‘5’ is passed as command line argument which is perfectly fine and in this case no
exception will be throws. Now see the output below, in this case also finally statement will get
executed.
Throw Keyword
The throw keyword is used to explicitly throw an exception. We can throw either checked or
unchecked exception. The throw keyword is normally used to throw custom exception.
Example
In the example shown below a method validage(int i) is used which will check the value of
passed parameter i and if the value is less than 18 than a ArithmeticException is thrown. Now as
you can see when we have called the method no try catch block is used which results in
termination of the program and message is displayed as “not valid” which is passed during
throwing of ArithmeticException object.
Output
However if during call of validage method try-catch block has been used then the program will
run normally
Output
Throws Keyword
The throws keyword is used to declare the exception, it provide information to the programmer
that there may occur an exception so during call of that method, and programmer must use
exceptional handling mechanism. Throws keyword is also used to propagate checked exception.
Example
In this example, exception is created by extending Exception class and the custom exception is
declared in the method validage(int i)
Case 1: During call of validage method exceptional handling is not used and code looks like this
and error is displayed in the compilation of the code.
Output
Case 2: During call of method validage exceptional handling is used with try-catch keyword
like this and the program runs as expected.
Output:
Case 3: During call of method validage exceptional handling is used without try-catch
keyword and throws keyword is used in main method as shown below
There will be no error now during compile time, but program will gets terminated when
exception event takes place.
Output
Case 4: Try to propagate custom exception not of type RuntimeException without declaring in
method using throws keyword. This will give compile time error
Output:
Case 5: Make custom exception by extending RunTimeException Class and try the same
method as use for Case 4. There will be no error now and the program runs as expected
Output
The try block cannot be present without either catch clause or finally clause.
Any code cannot be present in between the try, catch, finally blocks.
If you want to write a checked exception that is automatically enforced by the Handle or
Declare Rule, you need to extend the Exception class.
If you want to write a runtime exception, you need to extend the RuntimeException class.
There are two distinct types of Multitasking i.e. Processor-Based and Thread-Based
multitasking.
Ans: As both are types of multitasking there is very basic difference between the two.
Process-Based multitasking is a feature that allows your computer to run two or more
programs concurrently. For example you can listen to music and at the same time chat with
your friends on Facebook using browser. In Thread-based multitasking, thread is the smallest
unit of code, which means a single program can perform two or more tasks simultaneously. For
example a text editor can print and at the same time you can edit text provided that those two
tasks are perform by separate threads.
Ans: A multitasking thread requires less overhead than multitasking processor because of the
following reasons:
Processes require their own separate address space where threads share the address space
Benefits of Multithreading
Newborn State: When a thread object is created a new thread is born and said to be in
Newborn state.
Runnable State: If a thread is in this state it means that the thread is ready for execution and
waiting for the availability of the processor. If all threads in queue are of same priority then they
are given time slots for execution in round robin fashion
Running State: It means that the processor has given its time to the thread for execution. A
thread keeps running until the following conditions occurs
Thread give up its control on its own and it can happen in the following situations
A thread gets suspended using suspend() method which can only be revived with resume()
method
A thread is made to sleep for a specified period of time using sleep(time) method, where time
in milliseconds
A thread is made to wait for some event to occur using wait () method. In this case a thread can
be scheduled to run again using notify () method.
Blocked State: If a thread is prevented from entering into runnable state and subsequently
running state, then a thread is said to be in Blocked state.
Dead State: A runnable thread enters the Dead or terminated state when it completes its task
or otherwise terminates.
Fig: Life Cycle of Thread
Main Thread
Every time a Java program starts up, one thread begins running which is called as the main
thread of the program because it is the one that is executed when your program begins.
Child threads are produced from main thread
Often it is the last thread to finish execution as it performs various shut down operations
Creating a Thread
The easiest way to create a thread is to create a class that implements the Runnable interface. To
implement Runnable, a class need only implement a single method called run( ), which is
declared like this:
public void run( )
You will define the code that constitutes the new thread inside run() method. It is important to
understand that run() can call other methods, use other classes, and declare variables, just like
the main thread can.
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:
Here threadOb is an instance of a class that implements the Runnable interface and 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. The start( ) method is
shown here:
void start( );
Output:
Output:
Thread Methods
Ans: No, if a thread is started it can never be started again, if you do so, an
illegalThreadStateException is thrown. Example is shown below in which a same thread is
coded to start again
Output:
Causes the currently running thread to yield to any other threads of the same priority that are
waiting to be scheduled
Example
As you can see in the output below, thread A gets started and when condition if(i==2)
gets satisfied yield() method gets evoked and the control is relinquished from thread A
to thread B which run to its completion and only after that thread a regain the control
back.
Output
Example
Output
Output
Output
Thread Priority
Every Java thread has a priority that helps the operating system determine the order in which
threads are scheduled.
Threads with higher priority are more important to a program and should be allocated
processor time before lower-priority threads. However, thread priorities cannot guarantee the
order in which threads execute and very much platform dependent.
Example
In the above code, you can see Priorities of Thread is set to maximum for Thread A which lets it
to run to completion ahead of C which is set to minimum priority.
Output:
Use of isAlive() and join() method
The java.lang.Thread.isAlive() method tests if this thread is alive. A thread is alive if it has been
started and has not yet died. Following is the declaration for java.lang.Thread.isAlive() method
join() method waits for a thread to die. It causes the currently thread to stop executing until
the thread it joins with completes its task.
Example
When two or more threads need access to a shared resource, they need some way to ensure that
the resource will be used by only one thread at a time. The process by which this
synchronization is achieved is called thread synchronization. The synchronized keyword in
Java creates a block of code referred to as a critical section. Every Java object with a critical
section of code gets a lock associated with the object. To enter a critical section, a thread needs to
obtain the corresponding object's lock.
synchronized(object)
{
// statements to be synchronized
}
Problem without using Synchronization
In the following example method updatesum() is not synchronized and access by both the
threads simultaneously which results in inconsistent output. Making a method synchronized,
Java creates a “monitor” and hands it over to the thread that calls the method first time. As
long as the thread holds the monitor, no other thread can enter the synchronized section of the
code. Writing the method as synchronized will make one thread enter the method and till
execution is not complete no other thread can get access to the method.
Output when
method is declared
as synchronized
Output
Interthread Communication
It is all about making synchronized threads communicate with each other. It is a mechanism in
which a thread is paused running in its critical section and another thread is allowed to enter in the
same critical section to be executed. It is implemented by the following methods of Object Class:
wait( ): This method tells the calling thread to give up the monitor and go to sleep until some other
thread enters the same monitor and calls notify( ).
notify( ): This method wakes up the first thread that called wait( ) on the same object.
notifyAll( ): This method wakes up all the threads that called wait( ) on the same object. The
highest priority thread will run first.
These methods are implemented as final methods in Object, so all classes have them. All three
methods can be called only from within a synchronized context.
Example
Output 2: