Java Notes Unit - 5

8/8/2019 Java Notes Unit - 5

1/21

Object Oriented Programming EXCEPTION HANDLING & MULTITHREADINGUNIT - 5

Q) What Is an Exception? Give types of exceptions.

An exception is an event, which occurs during the execution of a program that

disrupts the normal flow of the program's instructions. Java Exceptions are basically Javaobjects.

When an error occurs within a method, the method creates an object and hands

it off to the runtime system. The object, called an exception object, contains

information about the error, including its type and the state of the program when the

error occurred. Creating an exception object and handing it to the runtime system is

called throwing an exception.

After a method throws an exception, the runtime system attempts to find

something to handle it. The list of methods is known as the call stack. The runtime

system searches the call stack for a method that contains a block of code that can

handle the exception. This block of code is called an exception handler. The search

begins with the method in which the error occurred and proceeds through the call

stack in the reverse order in which the methods were called. When an appropriate

handler is found, the runtime system passes the exception to the handler. An

exception handler is considered appropriate if the type of the exception object thrown

matches the type that can be handled by the handler.

The exception handler chosen is said to catch the exception. If the runtime

system exhaustively searches all the methods on the call stack without finding an

appropriate exception handler, as shown in the next figure, the runtime system (and,

consequently, the program) terminates.

Exceptions in Java are classified on the basis of the exception handled by the java

compiler. Java consists of the following type of built in exceptions:

1


2/21


Checked and Unchecked Exceptions

a) Checked exceptions are subclasss of Exception excluding class

RuntimeException and its subclasses. Checked Exceptions forces programmers to

deal with the exception that may be thrown. Example: Arithmetic exception. When a

checked exception occurs in a method, the method must either catch the exception

and take the appropriate action, or pass the exception on to its caller.

b) Unchecked exceptions are RuntimeException and any of its subclasses. Class

Error and its subclasses also are unchecked. Unchecked exceptions, however, the

compiler doesnt force the programmers to either catch the exception or declare it in

a throws clause. In fact, the programmers may not even know that the exception

could be thrown. Example: ArrayIndexOutOfBounds Exception.

10 Q) Give list of checked and unchecked exceptions.

List of Checked Exceptions

Following are the list of various checked exception that defined in the java. lang

package.

Exception Reason for Exception

ClassNotFoundExceptionThis Exception occurs when Java run-time system fail to

find the specified class mentioned in the program

InstantiationException This Exception occurs when you create an object of anabstract class and interface

IllegalAccessExceptionThis Exception occurs when you create an object of an

abstract class and interface2


3/21


NotSuchMethodExceptionThis Exception occurs when the method you call does

not exist in class

List of Unchecked Exceptions

Exception

Reason for Exception

ArithmeticException These Exception occurs, when you divide a number

by zero causes an Arithmetic Exception

ClassCastException

These Exception occurs, when you try to assign a

reference variable of a class to an incompatible

reference variable of another class

ArrayStoreException

These Exception occurs, when you assign an array

which is not compatible with the data type of that

arrayArrayIndexOutOfBoundsExcepti

on

These Exception occurs, when you assign an array

which is not compatible with the data type of that

array

NullPointerException

These Exception occurs, when you try to implement an

application without referencing the object and

allocating to a memory

NumberFormatException

These Exception occurs, when you try to convert a

string variable in an incorrect format to integer(numeric format) that is not compatible with each

other

11 Q) Explain how to handle exceptions in java.

Java exception handling mechanism enables you to catch exceptions in java using try,

catch, finally blocks.

Exceptions are handled using a try-catch-finally construct, which has the Syntax

try

{

}

catch ( )

{

// 0 or more

}

finally

{

3


4/21


// finally block

}

Try Block

Write the code where there is a possible to occur a run-time error in the program. If

there is an exception then try throws an exception to its corresponding run-time error

catch block. If no exception occurs the execution proceeds with the finally block else it

will look for the matching catch block to handle the error. Again if the matching catch

handler is not found execution proceeds with the finally block and the default

exception handler throws an exception. If an exception is generated within the try

block, the remaining statements in the try block are not executed.

Catch Block

Exceptions thrown during execution of the try block can be caught and handled in a

catch block. On exit from a catch block, normal execution continues and the finally

block is executed

(Though the catch block throws an exception).

Finally Block

A finally block is always executed, regardless of the cause of exit from the try block,

or whether any catch block was executed. Generally finally block is used for freeing

resources, cleaning up, closing connections etc. If the finally clock executes a control

transfer statement such as a return or a break statement, then this control statement

determines how the execution will proceed regardless of any return or control

statement present in the try or catch.

4


5/21


12 Q) what are rules for try, catch and finally block. Give one

example.

1. For each try block there can be zero or more catch blocks, but only one finally

block.

2. The catch blocks and finally block must always appear in conjunction with a try

block.

3. A try block must be followed by either at least one catch block or one finally block.

4. The order exception handlers in the catch block must be from the most specific

exception.

Lets examine each of these in detail.

public class DivideException1{

public static void main(String[] args)

{ division(100,0);

System.out.println("Main Program Terminating");

}

public static void division(int x, int y)

{int z=-1;

System.out.println("Computing Division.");

Try

{ z = x/y;

System.out.println("Result is : "+z);

}

catch(Exception e){

System.out.println("Exception : "+ e.getMessage());

}

finally

{

if(z!= -1){

System.out.println("Finally Block Executes");System.out.println("Result : "+ z);

}

5


6/21


else{

System.out.println("Finally Block Executes. Exception Occurred");

}

}

}}

Output

Computing Division

Exception: / by zero

Finally Block Executes. Exception Occurred

Main Program Terminating

As shown above when the divide by zero calculation is attempted, an

ArithmeticException is thrown. And program execution is transferred to the catch

statement. Because the exception is thrown from the try block, the remaining

statements of the try block are skipped. The finally block executes.

13 Q) How to handle multiple exceptions in java?

In java when we handle the exceptions then we can have multiple catch blocks for a

particular try block to handle many different kind of exceptions that may be

generated while running the program i.e. you can use more than one catch clause in a

single try block however every catch block can handle only one type of exception.

This mechanism is necessary when the try block has statement that raises different

type of exceptions.

The syntax for using this clause is given below:-

try

{

statement -1;

statement -2;

----------

statement -n;

}

catch(,)

6


7/21


{

//statements to handle the exception

}

catch(,)

{//statements to handle the exception

}

catch(,)

{

//statements to handle the exception

}

When an exception is thrown, normal execution is suspended. The runtime system

proceeds to find a matching catch block that can handle the exception. If no handler is

found, then the exception is dealt with by the default exception handler at the top

level.

Lets see an example given below which shows the implementation of multiple catch

blocks for a single try block.

7


8/21


public class Multi_Catch

{

public static void main (String args[])

{

int array[]={20,10,30};int num1=15,num2=0;

int res=0;

try

{

res = num1/num2;

System.out.println("The result is" +res);

for(int i=2;i>=0; i--)

{

System.out.println("The value of array are"

+array[i]);

}

}catch (ArrayIndexOutOfBoundsException e)

{

System.out.println("Error. Array is out of Bounds");

}

catch (ArithmeticException e)

{System.out.println ("Can't be divided by Zero");

}

}

}

OUTPUT:

C:\Raghu\>javac Multi_Catch.java

C:\Raghu\>java Multi_Catch

Can't be divided by Zero

8


9/21


In this example we have used two catch clause catching the exception

ArrayIndexOutOfBoundsException and ArithmeticException in which the

statements that may raise exception are kept under the try block. When the program

is executed, an exception will be raised. Now that time the first catch block is skipped

and the second catch block handles the error.

14Q) How to create user defined exceptions in java?

sometimes you may occasionally need to throw your own exception i.e. if you

encounter a situation where none of those exception describe your exception

accurately or if you can't find the appropriate exception in the Java API, you can code

a class that defines an exception that is more appropriate and that mechanism of

handling exception is called Custom or User Defined Exception.

In Java API all exception classes have two type of constructor. First is called

default constructor that doesn't accept any arguments. Another constructor accepts a

string argument that provides the additional information about the exception. So in

that way the Custom exception behaves like the rest of the exception classes in Java

API.

There are two primary use cases for a custom exception.

Your code can simply throw the custom exception when something goes

wrong.

You can wrap an exception that provides extra information by adding your own

message.

The code of a Custom exception:

public class ExceptionClassName extends

Exception

{

public ExceptionClassName(){ }

public ExceptionClassName(StringMessage)

{

super(message);

}

}

// This program creates a custom exception type

9


10/21


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");

}

public static void main(String args[])

{

try

{

compute(1);

compute(20);

} catch (MyException e) {

System.out.println("Caught " + e);

}

}

}

Q) what is a multithread? How threads improve performance of

java?Multithreading refers to two or more tasks executing concurrently within a single

program. A thread is an independent path of execution within a program. Many

10


11/21


threads can run concurrently within a program. Every thread in Java is created and

controlled by thejava.lang.Thread class. A Java program can have many threads,

and these threads can run concurrently, either asynchronously or synchronously.

Multithreading has several advantages over Multiprocessing such as;

Threads are lightweight compared to processes

Threads share the same address space and therefore can share both data and code

Context switching between threads is usually less expensive than between processes

Cost of thread intercommunication is relatively low that that of process

intercommunication

Threads allow different tasks to be performed concurrently.

The following figure shows the methods that are members of the Object and

Thread Class.

Thread Creation

There are two ways to create thread in java;

Implement the Runnable interface (java.lang.Runnable) By Extending the Thread class (java.lang.Thread)

Implementing the Runnable Interface

The Runnable Interface Signature

public interface Runnable {

void run();

}

One way to create a thread in java is to implement the Runnable Interface and theninstantiate an object of the class. We need to override the run() method into our class

which is the only method that needs to be implemented. The run() method contains

the logic of the thread.

The procedure for creating threads based on the Runnable interface is as

follows:

1. A class implements the Runnable interface, providing the run() method that will be

executed by the thread. An object of this class is a Runnable object.

11


12/21


2. An object of Thread class is created by passing a Runnable object as argument to

the Thread constructor. The Thread object now has a Runnable object that

implements the run() method.

3. The start() method is invoked on the Thread object created in the previous step.

The start() method returns immediately after a thread has been spawned.4. The thread ends when the run() method ends, either by normal completion or by

throwing an uncaught exception.

Below is a program that illustrates instantiation and running of threads using the

runnable interface instead of extending the Thread class. To start the thread you need

to invoke the start() method on your object.

class RunnableThread implements Runnable {

Thread runner;

public RunnableThread() {

}

public RunnableThread(String threadName) {

runner = new Thread(this, threadName); // (1) Create a new thread.

System.out.println(runner.getName());

runner.start(); // (2) Start the thread.

}

public void run() {//Display info about this particular thread

System.out.println(Thread.currentThread());

}

}

public class RunnableExample {

public static void main(String[] args) {

Thread thread1 = new Thread(new RunnableThread(), "thread1");

Thread thread2 = new Thread(new RunnableThread(), "thread2");

RunnableThread thread3 = new RunnableThread("thread3");

//Start the threads

thread1.start();

thread2.start();

try {

//delay for one second

Thread.currentThread().sleep(1000);} catch (InterruptedException e) {

}

//Display info about the main thread

12


13/21



}

}

Output

thread3

Thread[thread1,5,main]



Thread[main,5,main]private

Extending Thread Class

The procedure for creating threads based on extending the Thread is as follows:

1. A class extending the Thread class overrides the run() method from the Thread

class to define the code executed by the thread.

2. This subclass may call a Thread constructor explicitly in its constructors to initialize

the thread, using the super() call.

3. The start() method inherited from the Thread class is invoked on the object of the

class to make the thread eligible for running.

Below is a program that illustrates instantiation and running of threads by extending

the Thread class instead of implementing the Runnable interface. To start the thread

you need to invoke the start() method on your object.

class XThread extends Thread {

XThread() {

}

XThread(String threadName) {

super(threadName); // Initialize thread.

System.out.println(this);

start();

}

public void run() {

//Display info about this particular thread

System.out.println(Thread.currentThread().getName());

}

}

public class ThreadExample {

public static void main(String[] args) {

Thread thread1 = new Thread(new XThread(), "thread1");

13


14/21


Thread thread2 = new Thread(new XThread(), "thread2");

// The below 2 threads are assigned default names

Thread thread3 = new XThread();

Thread thread4 = new XThread();

Thread thread5 = new XThread("thread5");

//Start the threadsthread1.start();

thread2.start();

thread3.start();

thread4.start();

try {

//The sleep() method is invoked on the main thread to cause a one second delay.

Thread.currentThread().sleep(1000);

} catch (InterruptedException e) {

}

//Display info about the main thread


}

}

Output


thread1

thread5

thread2

Thread-3

Thread-2

Thread[main,5,main]

12Q) what is synchronization. How to implement it in java?

With respect to multithreading, Synchronization is a process of controlling the access

of shared resources by the multiple threads in such a manner that only one thread

can access a particular resource at a time.

In non synchronized multithreaded application, it is possible for one thread to

modify a shared object while another thread is in the process of using or updating the

objects value. Synchronization prevents such type of data corruption which may

otherwise lead to dirty reads and significant errors.

Generally critical sections of the code are usually marked with synchronized keyword.

An example of using Thread Synchronization is in The Producer/Consumer

Model.

14


15/21


Locks are used to synchronize access to a shared resource. A lock can be

associated with a shared resource Threads gain access to a shared resource by first

acquiring the lock associated with the object/block of code. At any given time, at most

only one thread can hold the lock and thereby have access to the shared resource. A

lock thus implements mutual exclusion.

The object lock mechanism enforces the following rules of synchronization:

A thread must acquire the object lock associated with a shared resource, before it

can enter the shared

resource. The runtime system ensures that no other thread can enter a shared

resource if another thread already holds the object lock associated with the shared

resource. If a thread cannot immediately acquire

the object lock, it is blocked, that is, it must wait for the lock to become available.

When a thread exits a shared resource, the runtime system ensures that the object lock is

also relinquished.

If another thread is waiting for this object lock, it can proceed to acquire the lock in order to

gain access

to the shared resource.

Classes also have a class-specific lock that is analogous to the object lock. Such

a lock is actually a

lock on the java.lang.Class object associated with the class. Given a class A, the

reference A.class

denotes this unique Class object. The class lock can be used in much the same way as

an object lock to

implement mutual exclusion.

There can be 2 ways through which synchronized can be implemented in Java: synchronized methods

synchronized blocks

Synchronized statements are same as synchronized methods. A synchronized

statement can only be

executed after a thread has acquired the lock on the object/class referenced in the

synchronized statement.

Synchronized Methods

15


16/21


Synchronized methods are methods that are used to control access to an object. A

thread only executes a synchronized method after it has acquired the lock for the

methods object or class. .If the lock is already held by another thread, the calling

thread waits. A thread relinquishes the lock simply by returning from the synchronized

method, allowing the next thread waiting for this lock to proceed.

Synchronized methods are useful in situations where methods can manipulate

the state of an object in ways that can corrupt the state if executed concurrently. This

is called a race condition. It occurs when two or more threads simultaneously update

the same value, and as a consequence, leave the value in an undefined or

inconsistent state. While a thread is inside a synchronized method of an object, all

other threads that wish to execute this synchronized method or any othersynchronized method of the object will have to wait until it gets the lock. This

restriction does not apply to the thread that already has the lock and is executing a

synchronized method of the object. Such a method can invoke other synchronized

methods of the object without being blocked. The non-synchronized methods of the

object can of course be called at any time by any thread.

Synchronized Blocks

Static methods synchronize on the class lock. Acquiring and relinquishing a class lock

by a thread in order to execute a static synchronized method, proceeds analogous to

that of an object lock for a synchronized instance method.

A thread acquires the class lock before it can proceed with the execution of any

static synchronized method in the class, blocking other threads wishing to execute

any such methods in the same class. This, of course, does not apply to static, non-

synchronized methods, which can be invoked at any time. Synchronization of static

methods in a class is independent from the synchronization of instance methods on

objects of the class. A sub class decides whether the new definition of an inherited

synchronized method will remain synchronized in the sub class. The synchronizedblock allows execution of arbitrary code to be synchronized on the lock of an arbitrary

object.

16


17/21


The general form of the synchronized block is as follows:

synchronized () {

}A compile-time error occurs if the expression produces a value of any primitive

type. If execution of the block completes normally, then the lock is released. If

execution of the block completes abruptly, then the lock is released. A thread can

hold more than one lock at a time. Synchronized statements can be nested.

Synchronized statements with identical expressions can be nested. The expression

must evaluate to a non-null reference value, otherwise, a NullPointerException is

thrown.

The code block is usually related to the object on which the synchronization is

being done. This is the case with synchronized methods, where the execution of the

method is synchronized on the lock of the current object:

public Object method() {

synchronized (this) { // Synchronized block on current object

// method block

}

}

Once a thread has entered the code block after acquiring the lock on the specified

object, no other thread will be able to execute the code block, or any other code

requiring the same object lock, until the lock is relinquished. This happens when the

execution of the code block completes normally or an uncaught exception is thrown.

13Q) Explain in detail about thread life cycle

When you are programming with threads, understanding the life cycle of thread is

very valuable. While a thread is alive, it is in one of several states. By invoking start()

method, it does not mean that the thread has access to CPU and start executing

straight away. Several factors determine how it will proceed.

Different states of a thread are:

17


18/21


1. New state : After the creations of Thread instance the thread is in this state

but before the start() method invocation. At this point, the thread is considered

not alive.

2. Runnable (Ready-to-run) state: A thread starts its life from Runnable state.

A thread first enters runnable state after the invoking of start() method but a

thread can return to this state after either running, waiting, sleeping or coming

back from blocked state also. On this state a thread is waiting for a turn on the

processor.

3. Running state: A thread is in running state that means the thread is currently

executing. There are several ways to enter in Runnable state but there is only

one way to enter in Running state: the scheduler select a thread from runnable

pool.

4. Dead state: A thread can be considered dead when its run() method

completes. If any thread comes on this state that means it cannot ever run

again.

5. Blocked: A thread can enter in this state because of waiting the resources that

are hold by another thread.

Different states implementing Multiple-Threads are:

As we have seen different states that may be occur with the single thread. A running

thread can enter to any non-runnable state, depending on the circumstances. A

thread cannot enter directly to the running state from non-runnable state; firstly it

18


19/21


goes to runnable state. Now lets understand the some non-runnable states which

may be occur handling the multithreads.

Sleeping: On this state, the thread is still alive but it is not runnable, it might

be return to runnable state later, if a particular event occurs. On this state a

thread sleeps for a specified amount of time. You can use the method sleep( )to stop the running state of a thread.

static void sleep(long millisecond) throws InterruptedException

Waiting for Notification: A thread waits for notification from another thread.

The thread sends back to runnable state after sending notification from another

thread.

final void wait(long timeout) throws InterruptedException

final void wait(long timeout, int nanos) throws InterruptedException

final void wait() throws InterruptedException

Blocked on I/O: The thread waits for completion of blocking operation. A

thread can enter on this state because of waiting I/O resource. In that case the

thread sends back to runnable state after availability of resources.

Blocked for joint completion: The thread can come on this state because of

waiting the completion of another thread.

Blocked for lock acquisition: The thread can come on this state because of

waiting to acquire the lock of an object.

Methods that can be applied apply on a Thread:

19


20/21


Some Important Methods defined in java.lang.Thread are shown in the table:

MethodReturn

TypeDescription

currentThread( )

ThreadReturns an object reference to the thread in which it isinvoked.

getName( ) String Retrieve the name of the thread object or instance.

start( ) void Start the thread by calling its runmethod.

run( ) voidThis method is the entry point to execute thread, like themain method for applications.

sleep( ) voidSuspends a thread for a specified amount of time (inmilliseconds).

isAlive( ) booleanThis method is used to determine the thread is running ornot.

activeCount()

intThis method returns the number of active threads in aparticular thread group and all its subgroups.

interrupt( ) void The method interrupts the threads on which it is invoked.

yield( ) voidBy invoking this method the current thread pause itsexecution temporarily and allow other threads to execute.

join( ) void

This method andjoin(long millisec) ThrowsInterruptedException. These two methods are invoked ona thread. These are not returned until either the threadhas completed or it is timed out respectively.

Thread Priorities:

20


21/21


Every Java thread has a priority that helps the operating system determine the order

in which threads are scheduled.

Java priorities are in the range between

MIN_PRIORITY (a constant of 1)

MAX_PRIORITY (a constant of 10).

By default, every thread is given priority NORM_PRIORITY (a constant of 5).

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.

Documents

Java Notes Unit - 5