Unit - 5

Multithreading in java

5.1 Thread life cycle and methods

In Java, multithreading is the process of running several threads at the same time.

A thread is the smallest unit of processing and is a lightweight sub-process. Multitasking is accomplished through the use of multiprocessing and multithreading.

Because threads share memory, we employ multithreading rather than multiprocessing. They conserve memory by not allocating a separate memory space, and context-switching between threads takes less time than processing.

Multithreading in Java is typically utilized in gaming, animation, and other similar applications.

Because Java is a multi-threaded programming language, we can use it to create multi-threaded programs. A multi-threaded program is made up of two or more portions that can operate in parallel, each of which can tackle a distinct task at the same time, maximizing the use of available resources, especially when your computer has several CPUs.

Multitasking is defined as the sharing of common processing resources, such as a CPU, by many processes. Multi-threading extends the concept of multitasking into programs by allowing you to divide certain operations within a single app into several threads. Each thread can execute in its own thread. Not only does the operating system split processing time among distinct apps, but it also divides it among each thread within an application.

Multi-threading allows you to write software in which multiple activities can run at the same time.

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 program. 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 single-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.

As most readers know, over the past few years, multi-core systems have become commonplace. Of course, single-core systems are still in widespread use. It is important to understand that Java’s multithreading features work in both types of systems. In a single-core system, concurrently executing threads share the CPU, with each thread receiving a slice of CPU time. Therefore, in a single-core system, two or more threads do not actually run at the same time, but idle CPU time is utilized. However, in multi-core systems, it is possible for two or more threads to actually execute simultaneously. In many cases, this can further improve program efficiency and increase the speed of certain operations.

Threads exist in several states. Here is a general description. A thread can be running. It can be ready to run as soon as it gets CPU time. A running thread can be suspended, which temporarily halts 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.

Life Cycle of a Thread

A thread goes through various stages in its life cycle. For example, a thread is born, started, runs, and then dies. The following diagram shows the complete life cycle of a thread.

Fig 1 - The complete life cycle of a thread

Following are the stages of the life cycle −

●        New − A new thread begins its life cycle in the new state. It remains in this state until the program starts the thread. It is also referred to as a born thread.

●        Runnable − After a newly born thread is started, the thread becomes runnable. A thread in this state is considered to be executing its task.

●        Waiting − Sometimes, a thread transitions to the waiting state while the thread waits for another thread to perform a task. A thread transitions back to the runnable state only when another thread signals the waiting thread to continue executing.

●        Timed Waiting − A runnable thread can enter the timed waiting state for a specified interval of time. A thread in this state transitions back to the runnable state when that time interval expires or when the event it is waiting for occurs.

●        Terminated (Dead) − A runnable thread enters the terminated state when it completes its task or otherwise terminates.

Thread Methods

Following is the list of important methods available in the Thread class.

The previous methods are invoked on a particular Thread object. The following methods in the Thread class are static. Invoking one of the static methods performs the operation on the currently running thread.

Example

The following ThreadClassDemo program demonstrates some of these methods of the Thread class. Consider a class DisplayMessage which implements Runnable −

// File Name : DisplayMessage.java

// Create a thread to implement Runnable

Public class DisplayMessage implements Runnable {

Private String message;

Public DisplayMessage(String message) {

This.message = message;

}

Public void run() {

While(true) {

System.out.println(message);

}

}

}

Following is another class which extends the Thread class −

// File Name : GuessANumber.java

// Create a thread to extend Thread

Public class GuessANumber extends Thread {

Private int number;

Public GuessANumber(int number) {

This.number = number;

}

Public void run() {

Int counter = 0;

Int guess = 0;

Do {

Guess = (int) (Math.random() * 100 + 1);

System.out.println(this.getName() + " guesses " + guess);

Counter++;

} while(guess != number);

System.out.println("** Correct!" + this.getName() + "in" + counter + "guesses.**");

}

}

Following is the main program, which makes use of the above-defined classes −

// File Name : ThreadClassDemo.java

Public class ThreadClassDemo {

Public static void main(String [] args) {

Runnable hello = new DisplayMessage("Hello");

Thread thread1 = new Thread(hello);

Thread1.setDaemon(true);

Thread1.setName("hello");

System.out.println("Starting hello thread...");

Thread1.start();

Runnable bye = new DisplayMessage("Goodbye");

Thread thread2 = new Thread(bye);

Thread2.setPriority(Thread.MIN_PRIORITY);

Thread2.setDaemon(true);

System.out.println("Starting goodbye thread...");

Thread2.start();

System.out.println("Starting thread3...");

Thread thread3 = new GuessANumber(27);

Thread3.start();

Try {

Thread3.join();

} catch (InterruptedException e) {

System.out.println("Thread interrupted.");

}

System.out.println("Starting thread4...");

Thread thread4 = new GuessANumber(75);

Thread4.start();

System.out.println("main() is ending...");

}

}

This will produce the following result. You can try this example again and again and you will get a different result every time.

Output

Starting hello thread...

Starting goodbye thread...

Hello

Hello

Hello

Hello

Hello

Hello

Goodbye

Goodbye

Goodbye

Goodbye

Goodbye

.......

Key takeaway

Multithreading is the process of running several threads at the same time.

Multithreading in Java is typically utilized in gaming, animation, and other similar applications.

A thread goes through various stages in its life cycle. For example, a thread is born, started, runs, and then dies. The following diagram shows the complete life cycle of a thread.

5.2 Runnable interface

Java.lang. Runnable is an interface that a class must implement if its instances are to be executed by a thread. Subclass Thread and implement Runnable are two techniques to start a new Thread. When a task can be accomplished by overriding simply the run() function of Runnable, there is no need to subclass Thread.

Steps to create a new Thread using Runnable

●      Make a Runnable implementer and use it to call the run() method.

●      Create a Thread object and pass the implementer to it; Thread has a function Object() { [native code] } that takes Runnable objects.

●      Invoke the Thread instance's start() method, which runs the implementer's run() method inside. When you call start(), it generates a new Thread that runs the code you wrote in run ().

When you call run() directly, it does not create and start a new Thread; instead, it continues to execute in the same thread. To start a new line of execution, call start() on the thread.

Example

Public class RunnableDemo {

Public static void main(String[] args)

{

System.out.println("Main thread is- "

+ Thread.currentThread().getName());

Thread t1 = new Thread(new RunnableDemo().new RunnableImpl());

t1.start();

}

Private class RunnableImpl implements Runnable {

Public void run()

{

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

+ ", executing run() method!");

}

}

}

Output

Main thread is- main

Thread-0, executing run() method!

The main thread executes the main method, while executing start on RunnableImpl produces and starts a new thread, Thread-0.

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. Several of those used is shown here:

Fig 2 - Thread class defines several methods

Thus far, all the examples in this book have used a single thread of execution. The remainder of this chapter explains how to use Thread and Runnable to create and manage threads, beginning with the one thread that all Java programs have: the main thread.

Create a Thread by Implementing a Runnable Interface

If your class is intended to be executed as a thread then you can achieve this by implementing a Runnable interface. You will need to follow three basic steps −

Step 1

As a first step, you need to implement a run() method provided by a Runnable interface. This method provides an entry point for the thread and you will put your complete business logic inside this method. Following is a simple syntax of the run() method −

Public void run( )

Step 2

As a second step, you will instantiate a Thread object using the following constructor −

Thread(Runnable threadObj, String threadName);

Where, threadObj is an instance of a class that implements the Runnable interface and threadName is the name given to the new thread.

Step 3

Once a Thread object is created, you can start it by calling start() method, which executes a call to run( ) method. Following is a simple syntax of start() method −

Void start();

Example

Here is an example that creates a new thread and starts running it −

Class RunnableDemo implements Runnable {

Private Thread t;

Private String threadName;

RunnableDemo( String name) {

ThreadName = name;

System.out.println("Creating " +  threadName );

}

Public void run() {

System.out.println("Running " +  threadName );

Try {

For(int i = 4; i > 0; i--) {

System.out.println("Thread: " + threadName + ", " + i);

// Let the thread sleep for a while.

Thread.sleep(50);

}

} catch (InterruptedException e) {

System.out.println("Thread " +  threadName + " interrupted.");

}

System.out.println("Thread " +  threadName + " exiting.");

}

Public void start () {

System.out.println("Starting " +  threadName );

If (t == null) {

t = new Thread (this, threadName);

t.start ();

}

}

}

Public class TestThread {

Public static void main(String args[]) {

RunnableDemo R1 = new RunnableDemo( "Thread-1");

R1.start();

RunnableDemo R2 = new RunnableDemo( "Thread-2");

R2.start();

}  

}

This will produce the following result −

Output

Creating Thread-1

Starting Thread-1

Creating Thread-2

Starting Thread-2

Running Thread-1

Thread: Thread-1, 4

Running Thread-2

Thread: Thread-2, 4

Thread: Thread-1, 3

Thread: Thread-2, 3

Thread: Thread-1, 2

Thread: Thread-2, 2

Thread: Thread-1, 1

Thread: Thread-2, 1

Thread Thread-1 exiting.

Thread Thread-2 exiting.

Key takeaway

Java.lang. Runnable is an interface that a class must implement if its instances are to be executed by a thread. Subclass Thread and implement Runnable are two techniques to start a new Thread.

5.3 Thread synchronization

Synchronization in java is the capability to control the access of multiple threads to any shared resource.

Java Synchronization is better option where we want to allow only one thread to access the shared resource.

When we start two or more threads in a program, it's possible that numerous threads will try to access the same resource, resulting in unexpected results due to concurrency difficulties. For example, if multiple threads try to write to the same file at the same time, the data may be corrupted because one of the threads can override data, or while one thread is opening and another is closing the same file.

As a result, it's necessary to synchronize many threads' actions and ensure that only one thread can access the resource at any given time. This is accomplished through the use of monitors. In Java, each object has its own monitor, which a thread can lock or unlock. On a display, only one thread can retain a lock at a time.

Using synchronized blocks, the Java programming language makes it relatively easy to create threads and synchronize their tasks. Within this block, you retain shared resources. The general form of the synchronized statement is as follows:

Syntax

Synchronized(objectidentifier)

{

// Access shared variables and other shared resources

}

The objec tidentifier is a reference to an object whose lock corresponds to the monitor represented by the synchronized statement. Now we'll look at two different ways to print a counter using two distinct threads. When threads are not synchronized, they publish counter values that are out of order, but when we print counter inside a synchronized() block, it prints counters that are very much in order for both threads.

Multithreading Example with  synchronization

Class PrintDemo {

Public void printCount() {

Try {

For(int i = 5; i > 0; i--) {

System.out.println("Counter --- " + i );

}

} catch (Exception e) {

System.out.println("Thread interrupted.");

}

}

}

Class ThreadDemo extends Thread {

Private Thread t;

Private String threadName;

PrintDemo PD;

ThreadDemo( String name, PrintDemo pd) {

ThreadName = name;

PD = pd;

}

Public void run() {

Synchronized(PD) {

PD.printCount();

}

System.out.println("Thread " + threadName + " exiting.");

}

Public void start () {

System.out.println("Starting " + threadName );

If (t == null) {

t = new Thread (this, threadName);

t.start ();

}

}

}

Public class TestThread {

Public static void main(String args[]) {

PrintDemo PD = new PrintDemo();

ThreadDemo T1 = new ThreadDemo( "Thread - 1 ", PD );

ThreadDemo T2 = new ThreadDemo( "Thread - 2 ", PD );

T1.start();

T2.start();

// wait for threads to end

Try {

T1.join();

T2.join();

} catch ( Exception e) {

System.out.println("Interrupted");

}

}

}

Output

Starting Thread - 1

Starting Thread - 2

Counter --- 5

Counter --- 4

Counter --- 3

Counter --- 2

Counter --- 1

Thread Thread - 1 exiting.

Counter --- 5

Counter --- 4

Counter --- 3

Counter --- 2

Counter --- 1

Thread Thread - 2 exiting.

Why use Synchronization

The synchronization is mainly used to

1. To prevent thread interference.
2. To prevent consistency problem.

Types of Synchronization

There are two types of synchronization

1. Process Synchronization
2. Thread Synchronization

Understanding the problem without Synchronization

In this example, there is no synchronization, so output is inconsistent. Let's see the example:

1. Class Table{  
2. Void printTable(int n){//method not synchronized  
3.   For(int i=1;i<=5;i++){  
4.     System.out.println(n*i);  
5.     Try{  
6.      Thread.sleep(400);  
7.     }catch(Exception e){System.out.println(e);}  
8.   }  
9.  
10. }  
11. }  
12.  
13. Class MyThread1 extends Thread{  
14. Table t;  
15. MyThread1(Table t){  
16. This.t=t;  
17. }  
18. Public void run(){  
19. t.printTable(5);  
20. }  
21.  
22. }  
23. Class MyThread2 extends Thread{  
24. Table t;  
25. MyThread2(Table t){  
26. This.t=t;  
27. }  
28. Public void run(){  
29. t.printTable(100);  
30. }  
31. }  
32.  
33. Class TestSynchronization1{  
34. Public static void main(String args[]){  
35. Table obj = new Table();//only one object  
36. MyThread1 t1=new MyThread1(obj);  
37. MyThread2 t2=new MyThread2(obj);  
38. t1.start();  
39. t2.start();  
40. }  
41. }  

Output: 5

100

10

200

15

300

20

400

25

500

Java synchronized method

If you declare any method as synchronized, it is known as synchronized method.

Synchronized method is used to lock an object for any shared resource.

When a thread invokes a synchronized method, it automatically acquires the lock for that object and releases it when the thread completes its task.

Key takeaway

Using synchronized blocks, the Java programming language makes it relatively easy to create threads and synchronize their tasks. Within this block, you retain shared resources.

5.4 Exception Handling: Benefits of exception handling

●      The Exception Handling in Java is one of the powerful mechanisms to handle the runtime errors so that the normal flow of the application can be maintained.

●      In Java, an exception is an event that disrupts the normal flow of the program. It is an object which is thrown at runtime.

What is Exception in Java

Dictionary Meaning: Exception is an abnormal condition.

In Java, an exception is an event that disrupts the normal flow of the program. It is an object which is thrown at runtime.

What is Exception Handling?

Exception Handling is a mechanism to handle runtime errors such as ClassNotFoundException, IOException, SQLException, RemoteException, etc.

The core advantage of exception handling is to maintain the normal flow of the application. An exception normally disrupts the normal flow of the application that is why we use exception handling. Let's take a scenario:

1. Statement 1; 
2. Statement 2; 
3. Statement 3; 
4. Statement 4; 
5. Statement 5;//exception occurs 
6. Statement 6; 
7. Statement 7; 
8. Statement 8; 
9. Statement 9; 
10. Statement 10; 

Suppose there are 10 statements in your program and there occurs an exception at statement 5, the rest of the code will not be executed i.e. statement 6 to 10 will not be executed. If we perform exception handling, the rest of the statement will be executed. That is why we use exception handling in Java.

Benefits of exception handling

●      When an exception occurs, exception handling guarantees that the program's flow is preserved.

●      This allows us to identify the different types of faults.

●      This allows us to develop error-handling code separately from the rest of the code.

When an exception occurs, exception handling ensures that the program's flow does not break. For example, if a programme has a large number of statements and an exception occurs in the middle of executing some of them, the statements after the exception will not be executed, and the programme will end abruptly.

By handling, we ensure that all of the statements are executed and that the program's flow is not disrupted.

Key takeaway

The Exception Handling in Java is one of the powerful mechanisms to handle the runtime errors so that the normal flow of the application can be maintained.

5.5 The classification of exceptions, exception hierarchy, Checked exceptions and unchecked exceptions

Hierarchy of Java Exception classes

The java.lang.Throwable class is the root class of Java Exception hierarchy which is inherited by two subclasses: Exception and Error.

All exception and error kinds are subclasses of the hierarchy's root class, Throwable. Exception is in charge of one branch. This class is used for unusual circumstances that user programmes should be aware of. An example of such an exception is the NullPointerException. The Java run-time system (JVM) uses another branch, Error, to identify issues related to the run-time environment (JRE). An example of such an error is StackOverflowError.

A hierarchy of Java Exception classes are given below:

Fig 3 - A hierarchy of Java Exception classes

Types of Java Exceptions

There are mainly two types of exceptions: checked and unchecked. Here, an error is considered as the unchecked exception. According to Oracle, there are three types of exceptions:

1. Checked Exception
2. Unchecked Exception
3. Error

Fig 4 – Exception handling

There are mainly two types of exceptions: checked and unchecked. An error is considered as the unchecked exception. However, according to Oracle, there are three types of exceptions namely:

1) Checked Exception:

1. ClassNotFoundException: The ClassNotFoundException is a kind of checked exception that is thrown when we attempt to use a class that does not exist.

Checked exceptions are those exceptions that are checked by the Java compiler itself.

2. FileNotFoundException: The FileNotFoundException is a checked exception that is thrown when we attempt to access a non-existing file.

3. InterruptedException: InterruptedException is a checked exception that is thrown when a thread is in sleeping or waiting state and another thread attempt to interrupt it.

4. InstantiationException: This exception is also a checked exception that is thrown when we try to create an object of abstract class or interface. That is, an InstantiationException exception occurs when an abstract class or interface is instantiated.

5. IllegalAccessException: The IllegalAccessException is a checked exception and it is thrown when a method is called in another method or class but the calling method or class does not have permission to access that method.

6. CloneNotSupportedException: This checked exception is thrown when we try to clone an object without implementing the cloneable interface.

7. NoSuchFieldException: This is a checked exception that is thrown when an unknown variable is used in a program.

8. NoSuchMethodException: This checked exception is thrown when the undefined method is used in a program.

2) Unchecked Exception

Let’s see a brief description of them.

1. ArithmeticException: This exception is thrown when arithmetic problems, such as a number is divided by zero, is occurred. That is, it is caused by maths error.

2. ClassCastException: The ClassCastException is a runtime exception that is thrown by JVM when we attempt to invalid typecasting in the program. That is, it is thrown when we cast an object to a subclass of which an object is not an instance.

3. IllegalArgumentException: This runtime exception is thrown by programmatically when an illegal or appropriate argument is passed to call a method. This exception class has further two subclasses:

●        Number Format Exception

●        Illegal Thread State Exception

Numeric Format Exception: Number Format Exception is thrown by programmatically when we try to convert a string into the numeric type and the process of illegal conversion fails. That is, it occurs due to the illegal conversion of a string to a numeric format.

Illegal Thread State Exception: Illegal Thread State Exception is a runtime exception that is thrown by programmatically when we attempt to perform any operation on a thread but it is incompatible with the current thread state.

4. IndexOutOfBoundsException: This exception class is thrown by JVM when an array or string is going out of the specified index. It has two further subclasses:

●        ArrayIndexOutOfBoundsException

●        StringIndexOutOfBoundsException

ArrayIndexOutOfBoundsException: ArrayIndexOutOfBoundsException exception is thrown when an array element is accessed out of the index.

StringIndexOutOfBoundsException: StringIndexOutOfBoundsException exception is thrown when a String or StringBuffer element is accessed out of the index.

5. Null Pointer Exception: Null Pointer Exception is a runtime exception that is thrown by JVM when we attempt to use null instead of an object. That is, it is thrown when the reference is null.

6. Array Store Exception: This exception occurs when we attempt to store any value in an array which is not of array type. For example, suppose, an array is of integer type but we are trying to store a value of an element of another type.

7. IllegalStateException: The IllegalStateException exception is thrown by programmatically when the runtime environment is not in an appropriate state for calling any method.

8. IllegalMonitorStateException: This exception is thrown when a thread does not have the right to monitor an object and tries to access wait(), notify(), and notifyAll() methods of the object.

9. NegativeArraySizeException: The NegativeArraySizeException exception is thrown when an array is created with a negative size.

3) Error

Error is irrecoverable. Some examples of errors are Out Of Memory Error, Virtual Machine Error, Assertion Error etc.

Difference between Checked and Unchecked Exceptions

Key takeaway

The classes that directly inherit the Throwable class except RuntimeException and Error are known as checked exceptions.

The classes that inherit the RuntimeException are known as unchecked exceptions.

5.6 Usage of try, catch, throw, throws and finally

Java provides five keywords that are used to handle the exception. The following table describes each.

Java try block

Java try block is used to enclose the code that might throw an exception. It must be used within the method.

If an exception occurs at the particular statement of try block, the rest of the block code will not execute. So, it is recommended not to keeping the code in try block that will not throw an exception.

Java try block must be followed by either catch or finally block.

Syntax of Java try-catch

1. Try{    
2. //code that may throw an exception    
3. }catch(Exception_class_Name ref){}    

Syntax of try-finally block

1. Try{    
2. //code that may throw an exception    
3. }finally{}    

Java catch block

Java catch block is used to handle the Exception by declaring the type of exception within the parameter. The declared exception must be the parent class exception ( i.e., Exception) or the generated exception type. However, the good approach is to declare the generated type of exception.

The catch block must be used after the try block only. You can use multiple catch block with a single try block.

Problem without exception handling

Let's try to understand the problem if we don't use a try-catch block.

Example 1

1. Public class TryCatchExample1 {  
2.  
3.    Public static void main(String[] args) {  
4.          
5.        Int data=50/0; //may throw exception   
6.          
7.        System.out.println("rest of the code");  
8.          
9.    }  
10.      
11. } 

Output:

Exception in thread "main" java.lang.ArithmeticException: / by zero

As displayed in the above example, the rest of the code is not executed (in such case, the rest of the code statement is not printed).

There can be 100 lines of code after exception. So all the code after exception will not be executed.

Solution by exception handling

Let's see the solution of the above problem by a java try-catch block.

Example 2

1. Public class TryCatchExample2 {  
2.  
3.    Public static void main(String[] args) {  
4.        Try  
5.        {  
6.        Int data=50/0; //may throw exception   
7.        }  
8.            //handling the exception  
9.        Catch(ArithmeticException e)  
10.        {  
11.            System.out.println(e);  
12.        }  
13.        System.out.println("rest of the code");  
14.    }  
15.      
16. }  

Output:

Java.lang.ArithmeticException: / by zero

Rest of the code

Now, as displayed in the above example, the rest of the code is executed, i.e., the rest of the code statement is printed.

Example 3

In this example, we also kept the code in a try block that will not throw an exception.

1. Public class TryCatchExample3 {  
2.  
3.    Public static void main(String[] args) {  
4.        Try  
5.        {  
6.        Int data=50/0; //may throw exception   
7.                         // if exception occurs, the remaining statement will not exceute  
8.        System.out.println("rest of the code");  
9.        }  
10.             // handling the exception   
11.        Catch(ArithmeticException e)  
12.        {  
13.            System.out.println(e);  
14.        }  
15.          
16.    }  
17.      
18. }  

Output:

Java.lang.ArithmeticException: / by zero

Here, we can see that if an exception occurs in the try block, the rest of the block code will not execute.

Example 4

Here, we handle the exception using the parent class exception.

1. Public class TryCatchExample4 {  
2.  
3.    Public static void main(String[] args) {  
4.        Try  
5.        {  
6.        Int data=50/0; //may throw exception   
7.        }  
8.            // handling the exception by using Exception class      
9.        Catch(Exception e)  
10.        {  
11.            System.out.println(e);  
12.        }  
13.        System.out.println("rest of the code");  
14.    }  
15.      
16. }  

Output:

Java.lang.ArithmeticException: / by zero

Rest of the code

Fig 5 -Internal working of java try-catch block

The JVM firstly checks whether the exception is handled or not. If exception is not handled, JVM provides a default exception handler that performs the following tasks:

●        Prints out exception description.

●        Prints the stack trace (Hierarchy of methods where the exception occurred).

●        Causes the program to terminate.

But if exception is handled by the application programmer, normal flow of the application is maintained i.e. rest of the code is executed.

Java catch multiple exceptions

Java Multi-catch block

A try block can be followed by one or more catch blocks. Each catch block must contain a different exception handler. So, if you have to perform different tasks at the occurrence of different exceptions, use java multi-catch block.

Points to remember

●        At a time only one exception occurs and at a time only one catch block is executed.

●        All catch blocks must be ordered from most specific to most general, i.e. catch for ArithmeticException must come before catch for Exception.

Example 1

Let's see a simple example of java multi-catch block.

1. Public class MultipleCatchBlock1 {  
2.  
3.    Public static void main(String[] args) {  
4.          
5.           Try{    
6.                Int a[]=new int[5];    
7.                a[5]=30/0;    
8.               }    
9.               Catch(ArithmeticException e)  
10.                  {  
11.                   System.out.println("Arithmetic Exception occurs");  
12.                  }    
13.               Catch(ArrayIndexOutOfBoundsException e)  
14.                  {  
15.                   System.out.println("ArrayIndexOutOfBounds Exception occurs");  
16.                  }    
17.               Catch(Exception e)  
18.                  {  
19.                   System.out.println("Parent Exception occurs");  
20.                  }             
21.               System.out.println("rest of the code");    
22.    }  
23. }  

Output:

Arithmetic Exception occurs

Rest of the code

Example 2

1. Public class MultipleCatchBlock2 {  
2.  
3.    Public static void main(String[] args) {  
4.          
5.           Try{    
6.                Int a[]=new int[5];    
7.                
8.                System.out.println(a[10]);  
9.               }    
10.               Catch(ArithmeticException e)  
11.                  {  
12.                   System.out.println("Arithmetic Exception occurs");  
13.                  }    
14.               Catch(ArrayIndexOutOfBoundsException e)  
15.                  {  
16.                   System.out.println("ArrayIndexOutOfBounds Exception occurs");  
17.                  }    
18.               Catch(Exception e)  
19.                  {  
20.                   System.out.println("Parent Exception occurs");  
21.                  }             
22.               System.out.println("rest of the code");    
23.    }  
24. }  

Output:

ArrayIndexOutOfBounds Exception occurs

Rest of the code

Example 3

In this example, try block contains two exceptions. But at a time only one exception occurs and its corresponding catch block is invoked.

1. Public class MultipleCatchBlock3 {  
2.  
3.    Public static void main(String[] args) {  
4.          
5.           Try{    
6.                Int a[]=new int[5];    
7.                a[5]=30/0;    
8.                System.out.println(a[10]);  
9.               }    
10.               Catch(ArithmeticException e)  
11.                  {  
12.                   System.out.println("Arithmetic Exception occurs");  
13.                  }    
14.               Catch(ArrayIndexOutOfBoundsException e)  
15.                  {  
16.                   System.out.println("ArrayIndexOutOfBounds Exception occurs");  
17.                  }    
18.               Catch(Exception e)  
19.                  {  
20.                   System.out.println("Parent Exception occurs");  
21.                  }             
22.               System.out.println("rest of the code");    
23.    }  
24. }  

Output:

Arithmetic Exception occurs

Rest of the code

Java Nested try block

The try block within a try block is known as nested try block in java.

Why use nested try block

Sometimes a situation may arise where a part of a block may cause one error and the entire block itself may cause another error. In such cases, exception handlers have to be nested.

Syntax:

1. ....  
2. Try  
3. {  
4.    Statement 1;  
5.    Statement 2;  
6.    Try  
7.    {  
8.        Statement 1;  
9.        Statement 2;  
10.    }  
11.    Catch(Exception e)  
12.    {  
13.    }  
14. }  
15. Catch(Exception e)  
16. {  
17. }  
18. ....  

Java nested try example

Let's see a simple example of java nested try block.

1. Class Excep6{  
2. Public static void main(String args[]){  
3.  Try{  
4.    Try{  
5.     System.out.println("going to divide");  
6.     Int b =39/0;  
7.    }catch(ArithmeticException e){System.out.println(e);}  
8.   
9.    Try{  
10.    Int a[]=new int[5];  
11.    a[5]=4;  
12.    }catch(ArrayIndexOutOfBoundsException e){System.out.println(e);}  
13.     
14.    System.out.println("other statement);  
15.  }catch(Exception e){System.out.println("handled");}  
16.  
17.  System.out.println("normal flow..");  
18. }  
19. }  

Java finally block

Java finally block is a block that is used to execute important code such as closing connection, stream etc.

Java finally block is always executed whether exception is handled or not.

Fig 6 - Java finally block follows try or catch block.

Note: If you don't handle exception, before terminating the program, JVM executes finally block(if any).

Why use java finally

●        Finally block in java can be used to put "cleanup" code such as closing a file, closing connection etc.

Usage of Java finally

Let's see the different cases where java finally block can be used.

Case 1

Let's see the java finally example where exception doesn't occur.

1. Class TestFinallyBlock{  
2.  Public static void main(String args[]){  
3.  Try{  
4.   Int data=25/5;  
5.   System.out.println(data);  
6.  }  
7.  Catch(NullPointerException e){System.out.println(e);}  
8.  Finally{System.out.println("finally block is always executed");}  
9.  System.out.println("rest of the code...");  
10.  }  
11. }  

Output:5

Finally block is always executed

Rest of the code...

Case 2

Let's see the java finally example where exception occurs and not handled.

1. Class TestFinallyBlock1{  
2.  Public static void main(String args[]){  
3.  Try{  
4.   Int data=25/0;  
5.   System.out.println(data);  
6.  }  
7.  Catch(NullPointerException e){System.out.println(e);}  
8.  Finally{System.out.println("finally block is always executed");}  
9.  System.out.println("rest of the code...");  
10.  }  
11. }  

Output:finally block is always executed

Exception in thread main java.lang.ArithmeticException:/ by zero

Java throw exception

Java throw keyword

The Java throw keyword is used to explicitly throw an exception.

We can throw either checked or unchecked exception in java by throw keyword. The throw keyword is mainly used to throw custom exception. We will see custom exceptions later.

The syntax of java throw keyword is given below.

1. Throw exception;  

Let's see the example of throw IOException.

1. Throw new IOException("sorry device error);  

Java throw keyword example

In this example, we have created the validate method that takes integer value as a parameter. If the age is less than 18, we are throwing the ArithmeticException otherwise print a message welcome to vote.

1. Public class TestThrow1{  
2.   Static void validate(int age){  
3.     If(age<18)  
4.      Throw new ArithmeticException("not valid");  
5.     Else  
6.      System.out.println("welcome to vote");  
7.   }  
8.   Public static void main(String args[]){  
9.      Validate(13);  
10.      System.out.println("rest of the code...");  
11.  }  
12. }  

Output:

Exception in thread main java.lang.ArithmeticException:not valid

Java throws keyword

The Java throws keyword is used to declare an exception. It gives information to the programmer that there may occur an exception so it is better for the programmer to provide the exception handling code so that normal flow can be maintained.

Exception Handling is mainly used to handle the checked exceptions. If there occurs any unchecked exception such as NullPointerException, it is programmers fault that he is not performing check up before the code being used.

Syntax of java throws

1. Return_type method_name() throws exception_class_name{  
2. //method code  
3. }  

Advantage of Java throws keyword

Now Checked Exception can be propagated (forwarded in call stack).

It provides information to the caller of the method about the exception.

Java throws example

Let's see the example of java throws clause which describes that checked exceptions can be propagated by throws keyword.

1. Import java.io.IOException;  
2. Class Testthrows1{  
3.  Void m()throws IOException{  
4.    Throw new IOException("device error");//checked exception  
5.  }  
6.  Void n()throws IOException{  
7.    m();  
8.  }  
9.  Void p(){  
10.   Try{  
11.    n();  
12.   }catch(Exception e){System.out.println("exception handled");}  
13.  }  
14.  Public static void main(String args[]){  
15.   Testthrows1 obj=new Testthrows1();  
16.   Obj.p();  
17.   System.out.println("normal flow...");  
18.  }  
19. }  

Output:

Exception handled

Normal flow...

Rule: If you are calling a method that declares an exception, you must either caught or declare the exception.

There are two cases:

1. Case1: You caught the exception i.e. handle the exception using try/catch.
2. Case2: You declare the exception i.e. specifying throws with the method.

Case1: You handle the exception

●        In case you handle the exception, the code will be executed fine whether exception occurs during the program or not.

1. Import java.io.*;  
2. Class M{  
3. Void method()throws IOException{  
4.  Throw new IOException("device error");  
5. }  
6. }  
7. Public class Testthrows2{  
8.   Public static void main(String args[]){  
9.    Try{  
10.     M m=new M();  
11.     m.method();  
12.    }catch(Exception e){System.out.println("exception handled");}     
13.  
14.    System.out.println("normal flow...");  
15.  }  
16. }  

Output:

Exception handled

Normal flow…

Case2: You declare the exception

●        In case you declare the exception, if exception does not occur, the code will be executed fine.

●        B)In case you declare the exception if exception occurs, an exception will be thrown at runtime because throws does not handle the exception.

A) Program if exception does not occur

1. Import java.io.*;  
2. Class M{  
3. Void method()throws IOException{  
4.  System.out.println("device operation performed");  
5. }  
6. }  
7. Class Testthrows3{  
8. Public static void main(String args[])throws IOException{//declare exception  
9.     M m=new M();  
10.     m.method();  
11.  
12.    System.out.println("normal flow...");  
13.  }  
14. }  

Output:

Device operation performed

Normal flow...

B) Program if exception occurs

1. Import java.io.*;  
2. Class M{  
3. Void method()throws IOException{  
4.  Throw new IOException("device error");  
5. }  
6. }  
7. Class Testthrows4{  
8.   Public static void main(String args[])throws IOException{//declare exception  
9.     M m=new M();  
10.     m.method();  
11.  
12.    System.out.println("normal flow...");  
13.  }  
14. }  

Output:

Runtime Exception

Difference between throw and throws in Java

There are many differences between throw and throws keywords. A list of differences between throw and throws are given below:

Java throw example

1. Void m(){  
2. Throw new ArithmeticException("sorry");  
3. }  

Java throws example

1. Void m()throws ArithmeticException{  
2. //method code  
3. }  

Java throw and throws example

1. Void m()throws ArithmeticException{  
2. Throw new ArithmeticException("sorry");  
3. }  

Difference between final, finally and finalize

There are many differences between final, finally and finalize. A list of differences between final, finally and finalize are given below:

Java final example

1. Class FinalExample{  
2. Public static void main(String[] args){  
3. Final int x=100;  
4. x=200;//Compile Time Error  
5. }}  

Java finally example

1. Class FinallyExample{  
2. Public static void main(String[] args){  
3. Try{  
4. Int x=300;  
5. }catch(Exception e){System.out.println(e);}  
6. Finally{System.out.println("finally block is executed");}  
7. }}  

Java finalize example

1. Class FinalizeExample{  
2. Public void finalize(){System.out.println("finalize called");}  
3. Public static void main(String[] args){  
4. FinalizeExample f1=new FinalizeExample();  
5. FinalizeExample f2=new FinalizeExample();  
6. f1=null;  
7. f2=null;  
8. System.gc();  
9. }}  

Key takeaway

Java try block is used to enclose the code that might throw an exception. It must be used within the method.

Java catch block is used to handle the Exception by declaring the type of exception within the parameter.

References:

1. T. Budd (2009), An Introduction to Object Oriented Programming, 3rd edition, Pearson Education, India.

2. J. Nino, F. A. Hosch (2002), An Introduction to programming and OO design using Java, John Wiley & sons, New Jersey.

3. Y. Daniel Liang (2010), Introduction to Java programming, 7th edition, Pearson education, India.

4. Object Oriented Programming with C++ by E Balagurusamy, Fifth Edition, TMH.

Unit - 5

Multithreading in java

Unit - 5

Multithreading in java

5.1 Thread life cycle and methods

In Java, multithreading is the process of running several threads at the same time.

A thread is the smallest unit of processing and is a lightweight sub-process. Multitasking is accomplished through the use of multiprocessing and multithreading.

Because threads share memory, we employ multithreading rather than multiprocessing. They conserve memory by not allocating a separate memory space, and context-switching between threads takes less time than processing.

Multithreading in Java is typically utilized in gaming, animation, and other similar applications.

Because Java is a multi-threaded programming language, we can use it to create multi-threaded programs. A multi-threaded program is made up of two or more portions that can operate in parallel, each of which can tackle a distinct task at the same time, maximizing the use of available resources, especially when your computer has several CPUs.

Multitasking is defined as the sharing of common processing resources, such as a CPU, by many processes. Multi-threading extends the concept of multitasking into programs by allowing you to divide certain operations within a single app into several threads. Each thread can execute in its own thread. Not only does the operating system split processing time among distinct apps, but it also divides it among each thread within an application.

Multi-threading allows you to write software in which multiple activities can run at the same time.

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 program. 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 single-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.

As most readers know, over the past few years, multi-core systems have become commonplace. Of course, single-core systems are still in widespread use. It is important to understand that Java’s multithreading features work in both types of systems. In a single-core system, concurrently executing threads share the CPU, with each thread receiving a slice of CPU time. Therefore, in a single-core system, two or more threads do not actually run at the same time, but idle CPU time is utilized. However, in multi-core systems, it is possible for two or more threads to actually execute simultaneously. In many cases, this can further improve program efficiency and increase the speed of certain operations.

Threads exist in several states. Here is a general description. A thread can be running. It can be ready to run as soon as it gets CPU time. A running thread can be suspended, which temporarily halts 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.

Life Cycle of a Thread

A thread goes through various stages in its life cycle. For example, a thread is born, started, runs, and then dies. The following diagram shows the complete life cycle of a thread.

Fig 1 - The complete life cycle of a thread

Following are the stages of the life cycle −

●        New − A new thread begins its life cycle in the new state. It remains in this state until the program starts the thread. It is also referred to as a born thread.

●        Runnable − After a newly born thread is started, the thread becomes runnable. A thread in this state is considered to be executing its task.

●        Waiting − Sometimes, a thread transitions to the waiting state while the thread waits for another thread to perform a task. A thread transitions back to the runnable state only when another thread signals the waiting thread to continue executing.

●        Timed Waiting − A runnable thread can enter the timed waiting state for a specified interval of time. A thread in this state transitions back to the runnable state when that time interval expires or when the event it is waiting for occurs.

●        Terminated (Dead) − A runnable thread enters the terminated state when it completes its task or otherwise terminates.

Thread Methods

Following is the list of important methods available in the Thread class.

The previous methods are invoked on a particular Thread object. The following methods in the Thread class are static. Invoking one of the static methods performs the operation on the currently running thread.

Example

The following ThreadClassDemo program demonstrates some of these methods of the Thread class. Consider a class DisplayMessage which implements Runnable −

// File Name : DisplayMessage.java

// Create a thread to implement Runnable

Public class DisplayMessage implements Runnable {

Private String message;

Public DisplayMessage(String message) {

This.message = message;

}

Public void run() {

While(true) {

System.out.println(message);

}

}

}

Following is another class which extends the Thread class −

// File Name : GuessANumber.java

// Create a thread to extend Thread

Public class GuessANumber extends Thread {

Private int number;

Public GuessANumber(int number) {

This.number = number;

}

Public void run() {

Int counter = 0;

Int guess = 0;

Do {

Guess = (int) (Math.random() * 100 + 1);

System.out.println(this.getName() + " guesses " + guess);

Counter++;

} while(guess != number);

System.out.println("** Correct!" + this.getName() + "in" + counter + "guesses.**");

}

}

Following is the main program, which makes use of the above-defined classes −

// File Name : ThreadClassDemo.java

Public class ThreadClassDemo {

Public static void main(String [] args) {

Runnable hello = new DisplayMessage("Hello");

Thread thread1 = new Thread(hello);

Thread1.setDaemon(true);

Thread1.setName("hello");

System.out.println("Starting hello thread...");

Thread1.start();

Runnable bye = new DisplayMessage("Goodbye");

Thread thread2 = new Thread(bye);

Thread2.setPriority(Thread.MIN_PRIORITY);

Thread2.setDaemon(true);

System.out.println("Starting goodbye thread...");

Thread2.start();

System.out.println("Starting thread3...");

Thread thread3 = new GuessANumber(27);

Thread3.start();

Try {

Thread3.join();

} catch (InterruptedException e) {

System.out.println("Thread interrupted.");

}

System.out.println("Starting thread4...");

Thread thread4 = new GuessANumber(75);

Thread4.start();

System.out.println("main() is ending...");

}

}

This will produce the following result. You can try this example again and again and you will get a different result every time.

Output

Starting hello thread...

Starting goodbye thread...

Hello

Hello

Hello

Hello

Hello

Hello

Goodbye

Goodbye

Goodbye

Goodbye

Goodbye

.......

Key takeaway

Multithreading is the process of running several threads at the same time.

Multithreading in Java is typically utilized in gaming, animation, and other similar applications.

A thread goes through various stages in its life cycle. For example, a thread is born, started, runs, and then dies. The following diagram shows the complete life cycle of a thread.

5.2 Runnable interface

Java.lang. Runnable is an interface that a class must implement if its instances are to be executed by a thread. Subclass Thread and implement Runnable are two techniques to start a new Thread. When a task can be accomplished by overriding simply the run() function of Runnable, there is no need to subclass Thread.

Steps to create a new Thread using Runnable

●      Make a Runnable implementer and use it to call the run() method.

●      Create a Thread object and pass the implementer to it; Thread has a function Object() { [native code] } that takes Runnable objects.

●      Invoke the Thread instance's start() method, which runs the implementer's run() method inside. When you call start(), it generates a new Thread that runs the code you wrote in run ().

When you call run() directly, it does not create and start a new Thread; instead, it continues to execute in the same thread. To start a new line of execution, call start() on the thread.

Example

Public class RunnableDemo {

Public static void main(String[] args)

{

System.out.println("Main thread is- "

+ Thread.currentThread().getName());

Thread t1 = new Thread(new RunnableDemo().new RunnableImpl());

t1.start();

}

Private class RunnableImpl implements Runnable {

Public void run()

{

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

+ ", executing run() method!");

}

}

}

Output

Main thread is- main

Thread-0, executing run() method!

The main thread executes the main method, while executing start on RunnableImpl produces and starts a new thread, Thread-0.

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. Several of those used is shown here:

Fig 2 - Thread class defines several methods

Thus far, all the examples in this book have used a single thread of execution. The remainder of this chapter explains how to use Thread and Runnable to create and manage threads, beginning with the one thread that all Java programs have: the main thread.

Create a Thread by Implementing a Runnable Interface

If your class is intended to be executed as a thread then you can achieve this by implementing a Runnable interface. You will need to follow three basic steps −

Step 1

As a first step, you need to implement a run() method provided by a Runnable interface. This method provides an entry point for the thread and you will put your complete business logic inside this method. Following is a simple syntax of the run() method −

Public void run( )

Step 2

As a second step, you will instantiate a Thread object using the following constructor −

Thread(Runnable threadObj, String threadName);

Where, threadObj is an instance of a class that implements the Runnable interface and threadName is the name given to the new thread.

Step 3

Once a Thread object is created, you can start it by calling start() method, which executes a call to run( ) method. Following is a simple syntax of start() method −

Void start();

Example

Here is an example that creates a new thread and starts running it −

Class RunnableDemo implements Runnable {

Private Thread t;

Private String threadName;

RunnableDemo( String name) {

ThreadName = name;

System.out.println("Creating " +  threadName );

}

Public void run() {

System.out.println("Running " +  threadName );

Try {

For(int i = 4; i > 0; i--) {

System.out.println("Thread: " + threadName + ", " + i);

// Let the thread sleep for a while.

Thread.sleep(50);

}

} catch (InterruptedException e) {

System.out.println("Thread " +  threadName + " interrupted.");

}

System.out.println("Thread " +  threadName + " exiting.");

}

Public void start () {

System.out.println("Starting " +  threadName );

If (t == null) {

t = new Thread (this, threadName);

t.start ();

}

}

}

Public class TestThread {

Public static void main(String args[]) {

RunnableDemo R1 = new RunnableDemo( "Thread-1");

R1.start();

RunnableDemo R2 = new RunnableDemo( "Thread-2");

R2.start();

}  

}

This will produce the following result −

Output

Creating Thread-1

Starting Thread-1

Creating Thread-2

Starting Thread-2

Running Thread-1

Thread: Thread-1, 4

Running Thread-2

Thread: Thread-2, 4

Thread: Thread-1, 3

Thread: Thread-2, 3

Thread: Thread-1, 2

Thread: Thread-2, 2

Thread: Thread-1, 1

Thread: Thread-2, 1

Thread Thread-1 exiting.

Thread Thread-2 exiting.

Key takeaway

Java.lang. Runnable is an interface that a class must implement if its instances are to be executed by a thread. Subclass Thread and implement Runnable are two techniques to start a new Thread.

5.3 Thread synchronization

Synchronization in java is the capability to control the access of multiple threads to any shared resource.

Java Synchronization is better option where we want to allow only one thread to access the shared resource.

When we start two or more threads in a program, it's possible that numerous threads will try to access the same resource, resulting in unexpected results due to concurrency difficulties. For example, if multiple threads try to write to the same file at the same time, the data may be corrupted because one of the threads can override data, or while one thread is opening and another is closing the same file.

As a result, it's necessary to synchronize many threads' actions and ensure that only one thread can access the resource at any given time. This is accomplished through the use of monitors. In Java, each object has its own monitor, which a thread can lock or unlock. On a display, only one thread can retain a lock at a time.

Using synchronized blocks, the Java programming language makes it relatively easy to create threads and synchronize their tasks. Within this block, you retain shared resources. The general form of the synchronized statement is as follows:

Syntax

Synchronized(objectidentifier)

{

// Access shared variables and other shared resources

}

The objec tidentifier is a reference to an object whose lock corresponds to the monitor represented by the synchronized statement. Now we'll look at two different ways to print a counter using two distinct threads. When threads are not synchronized, they publish counter values that are out of order, but when we print counter inside a synchronized() block, it prints counters that are very much in order for both threads.

Multithreading Example with  synchronization

Class PrintDemo {

Public void printCount() {

Try {

For(int i = 5; i > 0; i--) {

System.out.println("Counter --- " + i );

}

} catch (Exception e) {

System.out.println("Thread interrupted.");

}

}

}

Class ThreadDemo extends Thread {

Private Thread t;

Private String threadName;

PrintDemo PD;

ThreadDemo( String name, PrintDemo pd) {

ThreadName = name;

PD = pd;

}

Public void run() {

Synchronized(PD) {

PD.printCount();

}

System.out.println("Thread " + threadName + " exiting.");

}

Public void start () {

System.out.println("Starting " + threadName );

If (t == null) {

t = new Thread (this, threadName);

t.start ();

}

}

}

Public class TestThread {

Public static void main(String args[]) {

PrintDemo PD = new PrintDemo();

ThreadDemo T1 = new ThreadDemo( "Thread - 1 ", PD );

ThreadDemo T2 = new ThreadDemo( "Thread - 2 ", PD );

T1.start();

T2.start();

// wait for threads to end

Try {

T1.join();

T2.join();

} catch ( Exception e) {

System.out.println("Interrupted");

}

}

}

Output

Starting Thread - 1

Starting Thread - 2

Counter --- 5

Counter --- 4

Counter --- 3

Counter --- 2

Counter --- 1

Thread Thread - 1 exiting.

Counter --- 5

Counter --- 4

Counter --- 3

Counter --- 2

Counter --- 1

Thread Thread - 2 exiting.

Why use Synchronization

The synchronization is mainly used to

1. To prevent thread interference.
2. To prevent consistency problem.

Types of Synchronization

There are two types of synchronization

1. Process Synchronization
2. Thread Synchronization

Understanding the problem without Synchronization

In this example, there is no synchronization, so output is inconsistent. Let's see the example:

1. Class Table{  
2. Void printTable(int n){//method not synchronized  
3.   For(int i=1;i<=5;i++){  
4.     System.out.println(n*i);  
5.     Try{  
6.      Thread.sleep(400);  
7.     }catch(Exception e){System.out.println(e);}  
8.   }  
9.  
10. }  
11. }  
12.  
13. Class MyThread1 extends Thread{  
14. Table t;  
15. MyThread1(Table t){  
16. This.t=t;  
17. }  
18. Public void run(){  
19. t.printTable(5);  
20. }  
21.  
22. }  
23. Class MyThread2 extends Thread{  
24. Table t;  
25. MyThread2(Table t){  
26. This.t=t;  
27. }  
28. Public void run(){  
29. t.printTable(100);  
30. }  
31. }  
32.  
33. Class TestSynchronization1{  
34. Public static void main(String args[]){  
35. Table obj = new Table();//only one object  
36. MyThread1 t1=new MyThread1(obj);  
37. MyThread2 t2=new MyThread2(obj);  
38. t1.start();  
39. t2.start();  
40. }  
41. }  

Output: 5

100

10

200

15

300

20

400

25

500

Java synchronized method

If you declare any method as synchronized, it is known as synchronized method.

Synchronized method is used to lock an object for any shared resource.

When a thread invokes a synchronized method, it automatically acquires the lock for that object and releases it when the thread completes its task.

Key takeaway

Using synchronized blocks, the Java programming language makes it relatively easy to create threads and synchronize their tasks. Within this block, you retain shared resources.

5.4 Exception Handling: Benefits of exception handling

●      The Exception Handling in Java is one of the powerful mechanisms to handle the runtime errors so that the normal flow of the application can be maintained.

●      In Java, an exception is an event that disrupts the normal flow of the program. It is an object which is thrown at runtime.

What is Exception in Java

Dictionary Meaning: Exception is an abnormal condition.

In Java, an exception is an event that disrupts the normal flow of the program. It is an object which is thrown at runtime.

What is Exception Handling?

Exception Handling is a mechanism to handle runtime errors such as ClassNotFoundException, IOException, SQLException, RemoteException, etc.

The core advantage of exception handling is to maintain the normal flow of the application. An exception normally disrupts the normal flow of the application that is why we use exception handling. Let's take a scenario:

1. Statement 1; 
2. Statement 2; 
3. Statement 3; 
4. Statement 4; 
5. Statement 5;//exception occurs 
6. Statement 6; 
7. Statement 7; 
8. Statement 8; 
9. Statement 9; 
10. Statement 10; 

Suppose there are 10 statements in your program and there occurs an exception at statement 5, the rest of the code will not be executed i.e. statement 6 to 10 will not be executed. If we perform exception handling, the rest of the statement will be executed. That is why we use exception handling in Java.

Benefits of exception handling

●      When an exception occurs, exception handling guarantees that the program's flow is preserved.

●      This allows us to identify the different types of faults.

●      This allows us to develop error-handling code separately from the rest of the code.

When an exception occurs, exception handling ensures that the program's flow does not break. For example, if a programme has a large number of statements and an exception occurs in the middle of executing some of them, the statements after the exception will not be executed, and the programme will end abruptly.

By handling, we ensure that all of the statements are executed and that the program's flow is not disrupted.

Key takeaway

The Exception Handling in Java is one of the powerful mechanisms to handle the runtime errors so that the normal flow of the application can be maintained.

5.5 The classification of exceptions, exception hierarchy, Checked exceptions and unchecked exceptions

Hierarchy of Java Exception classes

The java.lang.Throwable class is the root class of Java Exception hierarchy which is inherited by two subclasses: Exception and Error.

All exception and error kinds are subclasses of the hierarchy's root class, Throwable. Exception is in charge of one branch. This class is used for unusual circumstances that user programmes should be aware of. An example of such an exception is the NullPointerException. The Java run-time system (JVM) uses another branch, Error, to identify issues related to the run-time environment (JRE). An example of such an error is StackOverflowError.

A hierarchy of Java Exception classes are given below:

Fig 3 - A hierarchy of Java Exception classes

Types of Java Exceptions

There are mainly two types of exceptions: checked and unchecked. Here, an error is considered as the unchecked exception. According to Oracle, there are three types of exceptions:

1. Checked Exception
2. Unchecked Exception
3. Error

Fig 4 – Exception handling

There are mainly two types of exceptions: checked and unchecked. An error is considered as the unchecked exception. However, according to Oracle, there are three types of exceptions namely:

1) Checked Exception:

1. ClassNotFoundException: The ClassNotFoundException is a kind of checked exception that is thrown when we attempt to use a class that does not exist.

Checked exceptions are those exceptions that are checked by the Java compiler itself.

2. FileNotFoundException: The FileNotFoundException is a checked exception that is thrown when we attempt to access a non-existing file.

3. InterruptedException: InterruptedException is a checked exception that is thrown when a thread is in sleeping or waiting state and another thread attempt to interrupt it.

4. InstantiationException: This exception is also a checked exception that is thrown when we try to create an object of abstract class or interface. That is, an InstantiationException exception occurs when an abstract class or interface is instantiated.

5. IllegalAccessException: The IllegalAccessException is a checked exception and it is thrown when a method is called in another method or class but the calling method or class does not have permission to access that method.

6. CloneNotSupportedException: This checked exception is thrown when we try to clone an object without implementing the cloneable interface.

7. NoSuchFieldException: This is a checked exception that is thrown when an unknown variable is used in a program.

8. NoSuchMethodException: This checked exception is thrown when the undefined method is used in a program.

2) Unchecked Exception

Let’s see a brief description of them.

1. ArithmeticException: This exception is thrown when arithmetic problems, such as a number is divided by zero, is occurred. That is, it is caused by maths error.

2. ClassCastException: The ClassCastException is a runtime exception that is thrown by JVM when we attempt to invalid typecasting in the program. That is, it is thrown when we cast an object to a subclass of which an object is not an instance.

3. IllegalArgumentException: This runtime exception is thrown by programmatically when an illegal or appropriate argument is passed to call a method. This exception class has further two subclasses:

●        Number Format Exception

●        Illegal Thread State Exception

Numeric Format Exception: Number Format Exception is thrown by programmatically when we try to convert a string into the numeric type and the process of illegal conversion fails. That is, it occurs due to the illegal conversion of a string to a numeric format.

Illegal Thread State Exception: Illegal Thread State Exception is a runtime exception that is thrown by programmatically when we attempt to perform any operation on a thread but it is incompatible with the current thread state.

4. IndexOutOfBoundsException: This exception class is thrown by JVM when an array or string is going out of the specified index. It has two further subclasses:

●        ArrayIndexOutOfBoundsException

●        StringIndexOutOfBoundsException

ArrayIndexOutOfBoundsException: ArrayIndexOutOfBoundsException exception is thrown when an array element is accessed out of the index.

StringIndexOutOfBoundsException: StringIndexOutOfBoundsException exception is thrown when a String or StringBuffer element is accessed out of the index.

5. Null Pointer Exception: Null Pointer Exception is a runtime exception that is thrown by JVM when we attempt to use null instead of an object. That is, it is thrown when the reference is null.

6. Array Store Exception: This exception occurs when we attempt to store any value in an array which is not of array type. For example, suppose, an array is of integer type but we are trying to store a value of an element of another type.

7. IllegalStateException: The IllegalStateException exception is thrown by programmatically when the runtime environment is not in an appropriate state for calling any method.

8. IllegalMonitorStateException: This exception is thrown when a thread does not have the right to monitor an object and tries to access wait(), notify(), and notifyAll() methods of the object.

9. NegativeArraySizeException: The NegativeArraySizeException exception is thrown when an array is created with a negative size.

3) Error

Error is irrecoverable. Some examples of errors are Out Of Memory Error, Virtual Machine Error, Assertion Error etc.

Difference between Checked and Unchecked Exceptions

Key takeaway

The classes that directly inherit the Throwable class except RuntimeException and Error are known as checked exceptions.

The classes that inherit the RuntimeException are known as unchecked exceptions.

5.6 Usage of try, catch, throw, throws and finally

Java provides five keywords that are used to handle the exception. The following table describes each.

Java try block

Java try block is used to enclose the code that might throw an exception. It must be used within the method.

If an exception occurs at the particular statement of try block, the rest of the block code will not execute. So, it is recommended not to keeping the code in try block that will not throw an exception.

Java try block must be followed by either catch or finally block.

Syntax of Java try-catch

1. Try{    
2. //code that may throw an exception    
3. }catch(Exception_class_Name ref){}    

Syntax of try-finally block

1. Try{    
2. //code that may throw an exception    
3. }finally{}    

Java catch block

Java catch block is used to handle the Exception by declaring the type of exception within the parameter. The declared exception must be the parent class exception ( i.e., Exception) or the generated exception type. However, the good approach is to declare the generated type of exception.

The catch block must be used after the try block only. You can use multiple catch block with a single try block.

Problem without exception handling

Let's try to understand the problem if we don't use a try-catch block.

Example 1

1. Public class TryCatchExample1 {  
2.  
3.    Public static void main(String[] args) {  
4.          
5.        Int data=50/0; //may throw exception   
6.          
7.        System.out.println("rest of the code");  
8.          
9.    }  
10.      
11. } 

Output:

Exception in thread "main" java.lang.ArithmeticException: / by zero

As displayed in the above example, the rest of the code is not executed (in such case, the rest of the code statement is not printed).

There can be 100 lines of code after exception. So all the code after exception will not be executed.

Solution by exception handling

Let's see the solution of the above problem by a java try-catch block.

Example 2

1. Public class TryCatchExample2 {  
2.  
3.    Public static void main(String[] args) {  
4.        Try  
5.        {  
6.        Int data=50/0; //may throw exception   
7.        }  
8.            //handling the exception  
9.        Catch(ArithmeticException e)  
10.        {  
11.            System.out.println(e);  
12.        }  
13.        System.out.println("rest of the code");  
14.    }  
15.      
16. }  

Output:

Java.lang.ArithmeticException: / by zero

Rest of the code

Now, as displayed in the above example, the rest of the code is executed, i.e., the rest of the code statement is printed.

Example 3

In this example, we also kept the code in a try block that will not throw an exception.

1. Public class TryCatchExample3 {  
2.  
3.    Public static void main(String[] args) {  
4.        Try  
5.        {  
6.        Int data=50/0; //may throw exception   
7.                         // if exception occurs, the remaining statement will not exceute  
8.        System.out.println("rest of the code");  
9.        }  
10.             // handling the exception   
11.        Catch(ArithmeticException e)  
12.        {  
13.            System.out.println(e);  
14.        }  
15.          
16.    }  
17.      
18. }  

Output:

Java.lang.ArithmeticException: / by zero

Here, we can see that if an exception occurs in the try block, the rest of the block code will not execute.

Example 4

Here, we handle the exception using the parent class exception.

1. Public class TryCatchExample4 {  
2.  
3.    Public static void main(String[] args) {  
4.        Try  
5.        {  
6.        Int data=50/0; //may throw exception   
7.        }  
8.            // handling the exception by using Exception class      
9.        Catch(Exception e)  
10.        {  
11.            System.out.println(e);  
12.        }  
13.        System.out.println("rest of the code");  
14.    }  
15.      
16. }  

Output:

Java.lang.ArithmeticException: / by zero

Rest of the code

Fig 5 -Internal working of java try-catch block

The JVM firstly checks whether the exception is handled or not. If exception is not handled, JVM provides a default exception handler that performs the following tasks:

●        Prints out exception description.

●        Prints the stack trace (Hierarchy of methods where the exception occurred).

●        Causes the program to terminate.

But if exception is handled by the application programmer, normal flow of the application is maintained i.e. rest of the code is executed.

Java catch multiple exceptions

Java Multi-catch block

A try block can be followed by one or more catch blocks. Each catch block must contain a different exception handler. So, if you have to perform different tasks at the occurrence of different exceptions, use java multi-catch block.

Points to remember

●        At a time only one exception occurs and at a time only one catch block is executed.

●        All catch blocks must be ordered from most specific to most general, i.e. catch for ArithmeticException must come before catch for Exception.

Example 1

Let's see a simple example of java multi-catch block.

1. Public class MultipleCatchBlock1 {  
2.  
3.    Public static void main(String[] args) {  
4.          
5.           Try{    
6.                Int a[]=new int[5];    
7.                a[5]=30/0;    
8.               }    
9.               Catch(ArithmeticException e)  
10.                  {  
11.                   System.out.println("Arithmetic Exception occurs");  
12.                  }    
13.               Catch(ArrayIndexOutOfBoundsException e)  
14.                  {  
15.                   System.out.println("ArrayIndexOutOfBounds Exception occurs");  
16.                  }    
17.               Catch(Exception e)  
18.                  {  
19.                   System.out.println("Parent Exception occurs");  
20.                  }             
21.               System.out.println("rest of the code");    
22.    }  
23. }  

Output:

Arithmetic Exception occurs

Rest of the code

Example 2

1. Public class MultipleCatchBlock2 {  
2.  
3.    Public static void main(String[] args) {  
4.          
5.           Try{    
6.                Int a[]=new int[5];    
7.                
8.                System.out.println(a[10]);  
9.               }    
10.               Catch(ArithmeticException e)  
11.                  {  
12.                   System.out.println("Arithmetic Exception occurs");  
13.                  }    
14.               Catch(ArrayIndexOutOfBoundsException e)  
15.                  {  
16.                   System.out.println("ArrayIndexOutOfBounds Exception occurs");  
17.                  }    
18.               Catch(Exception e)  
19.                  {  
20.                   System.out.println("Parent Exception occurs");  
21.                  }             
22.               System.out.println("rest of the code");    
23.    }  
24. }  

Output:

ArrayIndexOutOfBounds Exception occurs

Rest of the code

Example 3

In this example, try block contains two exceptions. But at a time only one exception occurs and its corresponding catch block is invoked.

1. Public class MultipleCatchBlock3 {  
2.  
3.    Public static void main(String[] args) {  
4.          
5.           Try{    
6.                Int a[]=new int[5];    
7.                a[5]=30/0;    
8.                System.out.println(a[10]);  
9.               }    
10.               Catch(ArithmeticException e)  
11.                  {  
12.                   System.out.println("Arithmetic Exception occurs");  
13.                  }    
14.               Catch(ArrayIndexOutOfBoundsException e)  
15.                  {  
16.                   System.out.println("ArrayIndexOutOfBounds Exception occurs");  
17.                  }    
18.               Catch(Exception e)  
19.                  {  
20.                   System.out.println("Parent Exception occurs");  
21.                  }             
22.               System.out.println("rest of the code");    
23.    }  
24. }  

Output:

Arithmetic Exception occurs

Rest of the code

Java Nested try block

The try block within a try block is known as nested try block in java.

Why use nested try block

Sometimes a situation may arise where a part of a block may cause one error and the entire block itself may cause another error. In such cases, exception handlers have to be nested.

Syntax:

1. ....  
2. Try  
3. {  
4.    Statement 1;  
5.    Statement 2;  
6.    Try  
7.    {  
8.        Statement 1;  
9.        Statement 2;  
10.    }  
11.    Catch(Exception e)  
12.    {  
13.    }  
14. }  
15. Catch(Exception e)  
16. {  
17. }  
18. ....  

Java nested try example

Let's see a simple example of java nested try block.

1. Class Excep6{  
2. Public static void main(String args[]){  
3.  Try{  
4.    Try{  
5.     System.out.println("going to divide");  
6.     Int b =39/0;  
7.    }catch(ArithmeticException e){System.out.println(e);}  
8.   
9.    Try{  
10.    Int a[]=new int[5];  
11.    a[5]=4;  
12.    }catch(ArrayIndexOutOfBoundsException e){System.out.println(e);}  
13.     
14.    System.out.println("other statement);  
15.  }catch(Exception e){System.out.println("handled");}  
16.  
17.  System.out.println("normal flow..");  
18. }  
19. }  

Java finally block

Java finally block is a block that is used to execute important code such as closing connection, stream etc.

Java finally block is always executed whether exception is handled or not.

Fig 6 - Java finally block follows try or catch block.

Note: If you don't handle exception, before terminating the program, JVM executes finally block(if any).

Why use java finally

●        Finally block in java can be used to put "cleanup" code such as closing a file, closing connection etc.

Usage of Java finally

Let's see the different cases where java finally block can be used.

Case 1

Let's see the java finally example where exception doesn't occur.

1. Class TestFinallyBlock{  
2.  Public static void main(String args[]){  
3.  Try{  
4.   Int data=25/5;  
5.   System.out.println(data);  
6.  }  
7.  Catch(NullPointerException e){System.out.println(e);}  
8.  Finally{System.out.println("finally block is always executed");}  
9.  System.out.println("rest of the code...");  
10.  }  
11. }  

Output:5

Finally block is always executed

Rest of the code...

Case 2

Let's see the java finally example where exception occurs and not handled.

1. Class TestFinallyBlock1{  
2.  Public static void main(String args[]){  
3.  Try{  
4.   Int data=25/0;  
5.   System.out.println(data);  
6.  }  
7.  Catch(NullPointerException e){System.out.println(e);}  
8.  Finally{System.out.println("finally block is always executed");}  
9.  System.out.println("rest of the code...");  
10.  }  
11. }  

Output:finally block is always executed

Exception in thread main java.lang.ArithmeticException:/ by zero

Java throw exception

Java throw keyword

The Java throw keyword is used to explicitly throw an exception.

We can throw either checked or unchecked exception in java by throw keyword. The throw keyword is mainly used to throw custom exception. We will see custom exceptions later.

The syntax of java throw keyword is given below.

1. Throw exception;  

Let's see the example of throw IOException.

1. Throw new IOException("sorry device error);  

Java throw keyword example

In this example, we have created the validate method that takes integer value as a parameter. If the age is less than 18, we are throwing the ArithmeticException otherwise print a message welcome to vote.

1. Public class TestThrow1{  
2.   Static void validate(int age){  
3.     If(age<18)  
4.      Throw new ArithmeticException("not valid");  
5.     Else  
6.      System.out.println("welcome to vote");  
7.   }  
8.   Public static void main(String args[]){  
9.      Validate(13);  
10.      System.out.println("rest of the code...");  
11.  }  
12. }  

Output:

Exception in thread main java.lang.ArithmeticException:not valid

Java throws keyword

The Java throws keyword is used to declare an exception. It gives information to the programmer that there may occur an exception so it is better for the programmer to provide the exception handling code so that normal flow can be maintained.

Exception Handling is mainly used to handle the checked exceptions. If there occurs any unchecked exception such as NullPointerException, it is programmers fault that he is not performing check up before the code being used.

Syntax of java throws

1. Return_type method_name() throws exception_class_name{  
2. //method code  
3. }  

Advantage of Java throws keyword

Now Checked Exception can be propagated (forwarded in call stack).

It provides information to the caller of the method about the exception.

Java throws example

Let's see the example of java throws clause which describes that checked exceptions can be propagated by throws keyword.

1. Import java.io.IOException;  
2. Class Testthrows1{  
3.  Void m()throws IOException{  
4.    Throw new IOException("device error");//checked exception  
5.  }  
6.  Void n()throws IOException{  
7.    m();  
8.  }  
9.  Void p(){  
10.   Try{  
11.    n();  
12.   }catch(Exception e){System.out.println("exception handled");}  
13.  }  
14.  Public static void main(String args[]){  
15.   Testthrows1 obj=new Testthrows1();  
16.   Obj.p();  
17.   System.out.println("normal flow...");  
18.  }  
19. }  

Output:

Exception handled

Normal flow...

Rule: If you are calling a method that declares an exception, you must either caught or declare the exception.

There are two cases:

1. Case1: You caught the exception i.e. handle the exception using try/catch.
2. Case2: You declare the exception i.e. specifying throws with the method.

Case1: You handle the exception

●        In case you handle the exception, the code will be executed fine whether exception occurs during the program or not.

1. Import java.io.*;  
2. Class M{  
3. Void method()throws IOException{  
4.  Throw new IOException("device error");  
5. }  
6. }  
7. Public class Testthrows2{  
8.   Public static void main(String args[]){  
9.    Try{  
10.     M m=new M();  
11.     m.method();  
12.    }catch(Exception e){System.out.println("exception handled");}     
13.  
14.    System.out.println("normal flow...");  
15.  }  
16. }  

Output:

Exception handled

Normal flow…

Case2: You declare the exception

●        In case you declare the exception, if exception does not occur, the code will be executed fine.

●        B)In case you declare the exception if exception occurs, an exception will be thrown at runtime because throws does not handle the exception.

A) Program if exception does not occur

1. Import java.io.*;  
2. Class M{  
3. Void method()throws IOException{  
4.  System.out.println("device operation performed");  
5. }  
6. }  
7. Class Testthrows3{  
8. Public static void main(String args[])throws IOException{//declare exception  
9.     M m=new M();  
10.     m.method();  
11.  
12.    System.out.println("normal flow...");  
13.  }  
14. }  

Output:

Device operation performed

Normal flow...

B) Program if exception occurs

1. Import java.io.*;  
2. Class M{  
3. Void method()throws IOException{  
4.  Throw new IOException("device error");  
5. }  
6. }  
7. Class Testthrows4{  
8.   Public static void main(String args[])throws IOException{//declare exception  
9.     M m=new M();  
10.     m.method();  
11.  
12.    System.out.println("normal flow...");  
13.  }  
14. }  

Output:

Runtime Exception

Difference between throw and throws in Java

There are many differences between throw and throws keywords. A list of differences between throw and throws are given below:

Java throw example

1. Void m(){  
2. Throw new ArithmeticException("sorry");  
3. }  

Java throws example

1. Void m()throws ArithmeticException{  
2. //method code  
3. }  

Java throw and throws example

1. Void m()throws ArithmeticException{  
2. Throw new ArithmeticException("sorry");  
3. }  

Difference between final, finally and finalize

There are many differences between final, finally and finalize. A list of differences between final, finally and finalize are given below:

Java final example

1. Class FinalExample{  
2. Public static void main(String[] args){  
3. Final int x=100;  
4. x=200;//Compile Time Error  
5. }}  

Java finally example

1. Class FinallyExample{  
2. Public static void main(String[] args){  
3. Try{  
4. Int x=300;  
5. }catch(Exception e){System.out.println(e);}  
6. Finally{System.out.println("finally block is executed");}  
7. }}  

Java finalize example

1. Class FinalizeExample{  
2. Public void finalize(){System.out.println("finalize called");}  
3. Public static void main(String[] args){  
4. FinalizeExample f1=new FinalizeExample();  
5. FinalizeExample f2=new FinalizeExample();  
6. f1=null;  
7. f2=null;  
8. System.gc();  
9. }}  

Key takeaway

Java try block is used to enclose the code that might throw an exception. It must be used within the method.

Java catch block is used to handle the Exception by declaring the type of exception within the parameter.

References:

1. T. Budd (2009), An Introduction to Object Oriented Programming, 3rd edition, Pearson Education, India.

2. J. Nino, F. A. Hosch (2002), An Introduction to programming and OO design using Java, John Wiley & sons, New Jersey.

3. Y. Daniel Liang (2010), Introduction to Java programming, 7th edition, Pearson education, India.

4. Object Oriented Programming with C++ by E Balagurusamy, Fifth Edition, TMH.