Threads

In Java
Multithreading
•Multithreading in java is a process of executing multiple threads simultaneously.

•Thread is basically a lightweight sub-process, a smallest unit of processing. Multiprocessing and

multithreading, both are used to achieve multitasking.

•But we use multithreading than multiprocessing because threads share a common memory area.

•They don’t allocate separate memory area so saves memory, and context-switching between the threads
takes less time than process.

•Java Multithreading is mostly used in games, animation etc.

Advantages of Multithreading:

1) It doesn’t block the user because threads are independent and you can perform multiple operations at same
time.

2) You can perform many operations together so it saves time.

3) Threads are independent so it doesn’t affect other threads if exception occur in a single thread.

4) A thread is a lightweight sub process, a smallest unit of processing. It is a separate path of execution.

5) Threads are independent, if there occurs exception in one thread, it doesn’t affect other threads. It shares a
common memory area.
 MULTI-THREADING VS MULTI-TASKING
Multithreading Multitasking
Multithreading Multitasking

It is a programming concept in which a program or It is an operating system concept in which multiple tasks
process is divided into two or more sub programs. are performed simultaneously.

It supports execution of multiple parts of a single It supports execution of multiple programs

program simultaneously. simultaneously.

The processor has to switch between different parts of The processor has to switch between different programs
thread or program

It is highly efficient It is less efficient compared to multithreading

A thread is the smallest unit in multithreading A program is smallest unit

It helps in developing efficient programs It helps in developing efficient operating systems.

 Life cycle of a Thread (Thread States)
A thread can be in one of the five states. According to sun, there is only 4 states in thread life cycle in java new,
runnable, non-runnable and terminated. There is no running state. But for better understanding the threads, we
are explaining it in the 5 states. The life cycle of the thread in java is controlled by JVM. The java thread states are
as follows:

1. New
2. Runnable
3. Running
4. Non-Runnable (Blocked)
5. Terminated
1) New
The thread is in new state if you create an instance of Thread class but before the invocation of start() method.

2) Runnable
The thread is in runnable state after invocation of start() method, but the thread scheduler has not selected it to be
the running thread.

3) Running
The thread is in running state if the thread scheduler has selected it.

4) Non-Runnable (Blocked)
This is the state when the thread is still alive, but is currently not eligible to run.

5) Terminated
A thread is in terminated or dead state when its run() method exits.
How to create thread
There are two ways to create a thread:
1.By extending Thread class
2.By implementing Runnable interface.

Thread class:
Thread class provide constructors and methods to create and perform operations on a thread.Thread class
extends Object class and implements Runnable interface.
Commonly used Constructors of Thread class:
•Thread()
•Thread(String name)
•Thread(Runnable r)
•Thread(Runnable r,String name)
Java Thread Example by extending Thread class
class Multi extends Thread{
public void run(){
System.out.println("thread is running...");
}
public static void main(String args[]){
Multi t1=new Multi();
t1.start();
}
}
OUTPUT: Thread is running…
By Implementing Runnable Interface

Java Thread Example by implementing Runnable interface

class Multi3 implements Runnable{
public void run(){
System.out.println("thread is running...");
}

public static void main(String args[]){

Multi3 m1=new Multi3();
Thread t1 =new Thread(m1);
t1.start();
}
}
OUTPUT: Thread is running…
Example to create three threads

class Thread_A extends Thread{ class threaddemo

public void run(){ {
for(int k=0;k<100;k++) public static void main(String ae[])
System.out.println("thread A is running..."); {
} Thread_A a=new Thread_A();
class Thread_B extends Thread{ Thread_B b=new Thread_B();
public void run(){ Thread_C c=new Thread_C();
for(int j=0;j<20;j++) a.start();
System.out.println("thread B is running..."); b.start();
} c.start();
class Thread_C extends Thread{ }
public void run(){ }
for(int i=0;i<10;i++)
System.out.println("thread C is running...");
}
Sleep(): method causes the currently executing thread public static void main(String[] args) throws
to sleep for the specified number of milliseconds, Exception {
subject to the precision and accuracy of system timers Thread t = new Thread(new ThreadDemo());
and schedulers. // this will call run() function
t.start();
Example: Thread t2 = new Thread(new ThreadDemo());
import java.lang.*; // this will call run() function
public class ThreadDemo implements Runnable t2.start();
{ }
public void run() { }
for (int i = 10; i< 13; i++) {
System.out.println(Thread.currentThread().getNa Expected Output:
me() + " " + i); Thread-0 10
Thread-1 10
try { Thread-0 11
// thread to sleep for 1000 milliseconds Thread-1 11
Thread.sleep(1000); Thread-0 12
} catch (Exception e) { Thread-1 12
System.out.println(e);
} }}
run(): }
}
public void run(){
System.out.println("running thread name is:"+Threa Output:
d.currentThread().getName()); running thread name is:Thread-0
System.out.println("running thread priority is:"+Thr running thread priority is:10
ead.currentThread().getPriority()); running thread name is:Thread-1
} running thread priority is:1
public static void main(String args[]){
TestMultiPriority1 m1=new TestMultiPriority1();
TestMultiPriority1 m2=new TestMultiPriority1();
m1.setPriority(Thread.MIN_PRIORITY);
m2.setPriority(Thread.MAX_PRIORITY);
m1.start();
m2.start();
Other Thread Methods:

public void suspend()

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

public void stop()

This method stops a thread completely.

public void resume()

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

public void wait()

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

public void notify()

Wakes up a single thread that is waiting on this object's monitor.
Priority of a Thread (Thread Priority):
Each thread have a priority. Priorities are represented by a number between 1 and 10. In most cases,
thread scheduler schedules the threads according to their priority (known as preemptive scheduling).
But it is not guaranteed because it depends on JVM specification that which scheduling it chooses.
3 constants defined in Thread class:
● public static int MIN_PRIORITY
● public static int NORM_PRIORITY
● public static int MAX_PRIORITY

Default priority of a thread is 5 (NORM_PRIORITY).

The value of MIN_PRIORITY is 1 and the value of MAX_PRIORITY is 10.
Example:

class TestMultiPriority1 extends Thread{

public void run(){
System.out.println("running thread name
is:"+Thread.currentThread().getName());
System.out.println("running thread priority
is:"+Thread.currentThread().getPriority());
}
public static void main(String args[]){
TestMultiPriority1 m1=new TestMultiPriority1();
TestMultiPriority1 m2=new TestMultiPriority1();
m1.setPriority(Thread.MIN_PRIORITY);
m2.setPriority(Thread.MAX_PRIORITY);
m1.start();
m2.start();
}
}
Output:running thread name is:Thread-0
running thread priority is:10
running thread name is:Thread-1
running thread priority is:1
Synchronization

If multiple threads are simultaneously trying to access the same resource strange results may occur. To overcome them java
synchronization is used. The operations performed on the resource must be synchronized.

Monitor is the key to synchronization. A monitor is an object that is used as a mutually exclusive lock.Only one thread can own a
monitor at a given time. When a thread acquires a lock, it is said to have entered the monitor. All other threads attempting to enter the
locked monitor will be suspended until the first thread exits the monitor (other threads are waiting at that time) .

Code can be synchronized in two ways:

1. Using synchronized Methods

2. Using synchronized Statement
1. Using synchronized Methods : Example:
class Table
synchronized void update()
{
{ synchronized void printTable(int n)
{//synchronized method
- -- - for(int i=1;i<=5;i++)
{
}
System.out.println(n*i);
When a method is declared as synchronized, java creates a try
monitor and hands it over to the thread that calls the {
method first time. As long as the thread holds the monitor Thread.sleep(400);
no other thread can enter the synchronized section of }catch(Exception e){System.out.println(e);}
code. }
}

}
class MyThread1 extends Thread{ public class TestSynchronization2{
Table t; public static void main(String args[]){
MyThread1(Table t){ Table obj = new Table();//only one object
this.t=t; MyThread1 t1=new MyThread1(obj);
} MyThread2 t2=new MyThread2(obj);
public void run(){ t1.start();
t.printTable(5); t2.start();
} }
} }
class MyThread2 extends Thread{
Table t; Output: 5
MyThread2(Table t){ 10
this.t=t; 15
20
}
25
public void run(){ 100
t.printTable(100); 200
} 300
} 400
500
2. Using synchronized Statement:
This is the general form of the synchronized statement:
synchronized(objRef)
{
// statements to be synchronized
}
objRef is a reference to the object being synchronized. A synchronized block ensures that a call to a
synchronized method that is a member of objRef’s class occurs only after the current thread has
successfully entered objRef’s monitor.
Example: class MyThread1 extends Thread{ public class TestSynchronizedBlock1{
class Table{ Table t; public static void main(String args[]){
void printTable(int n){ MyThread1(Table t){ Table obj = new Table();//only one object
MyThread1 t1=new MyThread1(obj);
synchronized(this){//synchronized block this.t=t;
MyThread2 t2=new MyThread2(obj);
for(int i=1;i<=5;i++){ }
t1.start();
System.out.println(n*i); public void run(){ t2.start();
try{ t.printTable(5); }
Thread.sleep(400); } }
}catch(Exception e){System.out.println(e); Output: 5
} } 10
class MyThread2 extends Thread{ 15
}
20
} Table t;
25
}//end of the method MyThread2(Table t){ 100
} this.t=t; 200
}
public void run(){
t.printTable(100);
}
}
 Deadlocks

Deadlock in java is a part of multithreading. Deadlock can occur

in a situation when a thread is waiting for an object lock, that is
acquired by another thread and second thread is waiting for an
object lock that is acquired by first thread. Since, both threads
are waiting for each other to release the lock, the condition is
called deadlock
Example: public void run() {
public class ThreadDeadlock { String name =
public static void main(String[] args) throws Thread.currentThread().getName();
InterruptedException {
System.out.println(name + " acquiring lock on
Object obj1 = new Object();
"+obj1);
Object obj2 = new Object();
Object obj3 = new Object(); synchronized (obj1) {
System.out.println(name + " acquired lock on
Thread t1 = new Thread(new SyncThread(obj1, obj2), "+obj1);
"t1"); work();
Thread t2 = new Thread(new SyncThread(obj2, obj3), System.out.println(name + " acquiring lock on
"t2"); "+obj2);
Thread t3 = new Thread(new SyncThread(obj3, obj1), synchronized (obj2) {
"t3"); System.out.println(name + " acquired lock on
"+obj2);
t1.start();
work();
Thread.sleep(5000);
}
t2.start();
Thread.sleep(5000); System.out.println(name + " released lock on
t3.start(); "+obj2);
} }
} System.out.println(name + " released lock on
class SyncThread implements Runnable{ "+obj1);
private Object obj1; System.out.println(name + " finished execution.");
private Object obj2; }
public SyncThread(Object o1, Object o2){
this.obj1=o1;
this.obj2=o2;
}
 private void work() { Output:
try {
Thread.sleep(30000); t1 acquiring lock on java.lang.Object@35888d06
} catch (InterruptedException e) { t1 acquired lock on java.lang.Object@35888d06
e.printStackTrace(); t2 acquiring lock on java.lang.Object@4fc96d95
} t2 acquired lock on java.lang.Object@4fc96d95
t3 acquiring lock on java.lang.Object@3894d1f3
}
t3 acquired lock on java.lang.Object@3894d1f3
} t1 acquiring lock on java.lang.Object@4fc96d95
t2 acquiring lock on java.lang.Object@3894d1f3
t3 acquiring lock on java.lang.Object@35888d06