Java Multithreading

Java MultithreadingKasun DissanayakeBlockedUnblockFollowFollowingMay 28The ability to execute several programs simultaneously is called Multitasking.

In system’s terminology is called as Multithreading.

Here the main program is divided into two or more subprograms (processes) which can be implemented at the same time parallel.

Examples:Railway ticket reservation system where multiple customers accessing the server.

Performing some execution while I/O block.

Games are very good examples of threading.

You can use multiple objects in games like cars, motorbikes, animals, people, etc.

All these objects are nothing but just threads that run your game application.

Multiple account holders accessing their accounts simultaneously on the server.

When you insert an ATM card, it starts a thread for performing your operations.

Typing MS Word document while listening to music.

What is Thread?A thread is similar to a program that has a single flow of control.

Every program has at least one thread and the thread has a beginning, body and an end.

And it executes commands sequentially.

So Multithreading means executing more than one commands in parallel.

The special thing is Java supports for the Multithreading.

So Java enables us to use multiple flows of control in developing programs.

Each flow of control (Thread) runs in parallel to others.

A program which contains multiple flows of control called a MultiThreaded Program.

Let's assume that the program has Threads likeMain Thread Thread A Thread BThread C Now first of all the main Thread initiate.

Then Thread A, B, and C run concurrently and share the resource jointly.

Since threads in Java are subprograms of the main application program and share the same memory space, they are known as Light- Weight Threads.

Important: Remember threads running in parallel does not really mean that they run at the same time.

All the threads are running on a single processor and the execution shared between the threads.

The Java compiler handles switching the control between the threads.

The life cycle of a ThreadDuring the lifetime of a Thread, There are many states it can enters.

Newborn State — When we create a thread Object, The Thread is born and it is in the newborn state.

Runnable State — Thread is ready for execution and waiting for the availability of processor.

Running State — The processor has given it’s time to the execution.

Blocked State — Thread is prevented from entering into the runnable state and running state.

This happens when the Thread is suspended, slept or waited in order to satisfy certain requirements.

Dead State — Running Thread ended his life cycle and completed executing the run method.

Thread ExceptionsSleep() method should enclose in a try block and follow by a catch block.

This is important because the sleep method throws an exception which should be caught.

If we do not catch the exception the program will not compile.

Java will throw an exception named IllegalThreadStateException whenever we attempt to invoke a method that a thread cannot handle in a given state.

Example: Sleeping method cannot deal with the resume() method because the sleeping thread cannot receive any instructions.

How to create a Thread?There are two ways to create a thread:By extending Thread classBy implementing Runnable interface.

The approach can be used depending on what the class we are creating require.


By extending Thread classThread class provide constructors and methods to create and perform operations on a thread.

Thread class extends Object class and implements Runnable interface.

Steps:Declare the class as extending the Thread Class.

Implement the run method.

Create the thread Object and call the Start method.

package threadtutorial;/** * * @author Kasun Dissanayake */class Multi extends Thread{ @Override public void run(){//your code here System.


println("thread is running.

"); }}public class ThreadTutorial {public static void main(String[] args) { Multi t1 = new Multi(); t1.

start();} }Here Multi t1 = new Multi(); statement creates the Object.

The Thread that will run this Object is not yet running.

The Thread is in a newborn state.

Now t1.

start(); statement leads the thread move to the runnable state.

Then the Java interpreter will schedule the thread to run by invoking this run() method.

Now the Thread is in running state.

Run this code segment then you will get a result like this.

How to stop a Thread?Whenever we want to stop a Thread from running state we should call it’s stop() method.

It will move the Thread’s Running state to the Dead state.

The thread will move to the dead state automatically when it reaches the end of its method.

Example :A program which includes a thread to display numbers 1 to 10.

If the number reaches to 5, stop the thread.

package threadtutorial;/** * * @author Kasun Dissanayake */class Test extends Thread{ public void run(){ for (int i = 0; i < 10; i++) { if(i == 5){ stop(); } System.


println(i); } }}public class ThreadTutorial {public static void main(String[] args) {Test test = new Test(); test.

start();} }How to Block a Thread?A Thread can temporarily be suspended or blocked from entering to the Runnable and subsequently running state by using,sleep(); —Thread gets started after a specified time interval unless it is interrupted.

suspend(); — This method puts a thread in the suspended state and can be resumed using resume() method.

wait(); — Causes the current thread to wait until another thread invokes the notify().

notify(); — Wakes up a single thread that is waiting on this object’s monitor.

resume(); — This method resumes a thread, which was suspended using suspend() method.

stop(); — This method stops a thread completely.

The difference between wait() and sleep()wait() is an instance method that’s used for thread synchronization.

It can be called on any object, as it’s defined right on java.


Object, but it can only be called from a synchronized block.

It releases the lock on the object so that another thread can jump in and acquire a lock.

On the other hand, Thread.

sleep() is a static method that can be called from any context.


sleep() pauses the current thread and does not release any locks.

When we use the sleep() method, a thread gets started after a specified time interval, unless it is interrupted.

For wait(), the waking up process is a bit more complicated.

We can wake the thread by calling either the notify() or notifyAll() methods on the monitor that is being waited on.

Use notifyAll() instead of notify() when you want to wake all threads that are in the waiting state.

Similarly to the wait()method itself, notify(), and notifyAll() have to be called from the synchronized context.

Example :Write a program using threads to display numbers 1 to 10.

If the number equals to 5 sleep the thread 5000 milliseconds.

(Here Sleep() method should enclose in a try block and follow by a catch block.

)package threadtutorial;/** * * @author Kasun Dissanayake */class Test extends Thread{ public void run(){ for (int i = 0; i < 10; i++) { if(i == 5){ try { Thread.

sleep(5000); } catch (InterruptedException e) { e.

printStackTrace(); } } System.


println(i); } }}public class ThreadTutorial {public static void main(String[] args) {Test test = new Test(); test.

start();} }Thread PriorityIn Java, we can assign a priority to a Thread which affects the order in the schedule for running.

The Threads which have the same priority has an equal priority (This done by the Java scheduler) and they share the processor on a first come first serve manner.

We can set a Priority of a Thread using setpriority() method as follows.


setpriority(int number);the number is an Integer value (value between 1 -10)which is the Thread’s priority.

Thread class defines several priority constants.


This is equal to value 5.

Exercise:A program which includes Class A and Class B.

The Class A uses a thread to display numbers from 1–10 and Class B uses a Thread to display numbers 10 -1.

Priority as Class A Thread — Max and Class B Thread — Minpackage threadtutorial;/** * * @author Kasun Dissanayake */class A extends Thread{ public void run(){ System.


println("Class A method.

"); for (int i = 0; i < 10; i++) { System.


println(i); } }}class B extends Thread{ public void run(){ System.


println("Class B method.

"); for (int i = 10; i > 0; i–) { System.


println(i); } }}public class ThreadTutorial {public static void main(String[] args) { A a = new A(); B b = new B(); a.





start(); b.

start();} }Execute the code.

Then you will get a result like this.

SynchronizationIn the run, method Threads try to use some resources which lie inside the run method as well as outside the run method.

If two Threads try to reach the same resource there may be happening a problem.

Then Java gives us a technique to overcome this problem named Synchronization.

Here we can use a synchronized method to implement Synchronization mechanism.

The synchronization is mainly used toTo prevent thread interference.

To prevent consistency problem.

When we declare a method as synchronized, Java creates a monitor and hand it over to the Thread which is first called.

Other threads cannot access to that synchronized code segment.

Example://example of java synchronized method class Table{ synchronized void printTable(int n){//synchronized method for(int i=1;i<=5;i++){ System.


println(n*i); try{ Thread.

sleep(400); }catch(Exception e){System.


println(e);} } } } class MyThread1 extends Thread{ Table t; MyThread1(Table t){ this.

t=t; } public void run(){ t.

printTable(5); } }class MyThread2 extends Thread{ Table t; MyThread2(Table t){ this.

t=t; } public void run(){ t.

printTable(100); } } public class Example6{ public static void main(String args[]){ Table obj = new Table();//only one object MyThread1 t1=new MyThread1(obj); MyThread2 t2=new MyThread2(obj); t1.

start(); t2.

start(); } }Execute the code and you will get a result like this.

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

Then the second thread MyThread2 invokes and executes.


By implementing Runnable interfaceThe runnable interface declares the run() method that is required for implementing threads in our programs.

Steps:Declare the class as implementing the Runnable Interface.

Implement the run methodCreate a thread by defining an Object that is instantiated from this runnable class as the target of the ThreadCall the thread’s start() method to run the threadpackage threadtutorial;/** * * @author Kasun Dissanayake */class Test implements Runnable{ public void run(){ for (int i = 0; i < 10; i++) { System.


println(i); } }}public class ThreadTutorial {public static void main(String[] args) {Test test = new Test(); Thread thread = new Thread(test); thread.

start();} }As always, you can check out the examples provided in this article over on GitHub.

Thank you!.. More details

Leave a Reply