Introduction

Executing several tasks simultaneously known as multitasking. There are two types of multitasking

1. Process Based Multitasking - executing several tasks simultaneously, where each task is a separate independent process is called process based multitasking.
2. Thread Based Multitasking - executing several tasks simultaneously where each task is a separate independent part of the same program is called thread based multitasking and each independent part is called thread. it is best suitable for programmatic level.

Whether it is a process based or thread based, the main objective of multitasking is to improve performance of the system by reduce the response time. the main application areas of multitasking are developing video games, multimedia graphics, implementing animations etc.

Java provides inbuilt support for multi-threading by introducing a rich API (Thread, Runnable ThreadGroup, ThreadLocal)

Define, Initiate and Start a Thread

We can define a thread in the following two ways.

• By extending Thread class
• By implementing Runnable Interface

Thread Scheduler - when multiple threads are waiting to get chance for execution, this decides by thread scheduler. whose behavior is JVM vendor dependent, so we can't expect exact execution order and exact output. Thread scheduler is part of JVM.

Difference between t.start( ) and t.run( )

• In the case of t.start( ) a new thread will be create and this thread is responsible to execute run( ).
• In the case of t.run( ) no new thread creates, run( ) method only execute just like a normal method call.

Importance of Thread class start( ) method

To start a thread, the required mandatory activities like registering thread with thread scheduler will be perform automatically by thread class start( ) method. because programmer is not responsible to perform this activity the programmer only defines the job of the thread. hence, thread class start( ) plays very important role and without executing that method there is no chance of starting a new thread.

• If we are not overriding run( ) method then thread class run( ) will be execute which has empty implementation and hence we won't get any output.
• If we want to define our job then it's compulsory we should override the run( )
• Override of the run( ) is possible, but the thread class start( ) will always call no argument run( ) only. but another run( ) we have to call explicitly like a normal method call.
• If we override start( ) then start( ) will be executed just like a normal method call and no new thread will be create.

Life cycle of Thread

1. New State (Mythread t = new Mythread())

t.start( )

2. Ready / Runnable State

If thread scheduler allocates CPU

3. Running State

yield( ) join( ) sleep( ) wait( ) notify( ) notify All( )

4. If run( ) method completed

Dead State

Define a Thread by implementing "Runnable Interface"

We can define a thread by implementing Runnable Interface also. Runnable Interface present in java.lang package and contains only one method run()

Getting and Setting

Every thread in Java has some name, it may be provided by programmer or default name by the JVM. We have two methods of thread class to get and set name of thread.

public final String getName( );

public final void setName(StringName);

class Test {

public static void main(String[] args) {

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

Thread.currentThread( ).setName("arjava");

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

} }

Note: We can get current executing thread reference by using the following method of thread class. public class Thread current.Thread( );

Thread Priorities

Every thread in Java has some priority but the range of thread priorities is 1 to 10, 1 is least and 10 is highest. Thread class defines the following constants to define some standard priorities

• Thread.MIN_PRIORITY 1
• Thread.NORM_PRIORITY 5
• Thread.MAX_PRIORITY 10

Thread scheduler uses this priorities while allocating CPU

The thread which having highest priority will get chance first.

If two thread having same priority then we can't expect exact execution order, it depends on thread scheduler.

Default Priority

The default priority only for the main thread is 5, but for all the remaining threads it will be inheriting from the parent, i.e., whatever the priority parent has the same priority will be inheriting to the child. Thread class defines the following two methods to get and set priority of a thread

public final int getPriority( );

public final void setPriority(int p);

The allowed values will be 1 to 10, otherwise we will get IllegalArgumentException

t.setPriority(1);

t.setPriority(10);

Prevent Thread Execution Method

we can prevent thread from execution by using the followings methods.

yield( ) - To pause current executing thread for giving the chance to remaining waiting threads of same priority. if there are no waiting threads or all threads have low priority then same thread will continue it's execution once again.

Signature : public static native void yield( )

join( ) - If a thread wants to wait until completing some other threads then we should go for join( ) method. If thread t1 executes and t2.join( ) then t1 thread will enter into waiting state until t2 completes. once t2 completes then t1 will continue executes it's execution.

• public final void join() throws InterruptedException
• public final void join(long ms) throws InterruptedException
• public final void join(long ms, int ns) throws InterruptedException

Join( ) method is overloaded and every join( ) throws Interrupted Exception. hence, whenever we are using join() we have to handle InterruptedException, either by try catch or by throws. otherwise we will get compile time error.

sleep( ) - If a thread don't want to perform any operation for a particular amount of time then we should use sleep( )

• public static void sleep(long ms) throws InterruptedException
• public static void sleep(long ms, int ns) throws InterruptedException

Whenever we are using sleep( ) we have to handle InterruptedException, otherwise we will get compile time error.

static: sleep method calls Thread.sleep( ) means class name t.start( ); t is object, so it is instance or non static

Note: A thread can interrupt another sleeping or waiting thread for this Thread class defines interrupt( ) method. public void interrupt( )

Difference between yield( ) join( ) and sleep( )

yield( )

• To pause current executing thread for giving the chance to remaining waiting threads of same priority.
• Static
• No Overloaded
• No final
• No InterruptedException
• native

join( )

• If a thread wants to wait until completing some other threads then we should go for join( ) method.
• No static
• Overloaded
• final
• InterruptedException
• No native

sleep( )

• If a thread don't want to perform any operation for a particular amount of time then we should use sleep( )
• Static
• Overloaded
• No final
• InterruptedException
• sleep(long ms) is native, sleep(long ms, int ns) is non native

Synchronization

• Synchronized is the modifier applicable only for methods and blocks.
• If a method or block declared as synchronized then at a time only one thread is allowed to execute that method or block on the given object.
• The main advantage of synchronized keyword is we can resolve data inconsistency problem.
• The main limitation of synchronized keyword is it increases waiting time of the threads and effects performance of the system.
• Every object in java has a unique lock synchronization concept internally implemented.
• If a thread wants to execute any synchronized method on the given object, first it has to get the lock of that object. once thread gets lock then it is allowed to execute any synchronized method on that object.
• Once synchronized method completes then automatically lock will be release.

Class Level Lock

• Every class in java has a unique lock.
• If a thread wants to execute a static synchronized method then there is required class level lock.
• While thread executing a static synchronized method then all remaining threads are not allowed to execute any static synchronized method of that class simultaneously, but following methods can execute simultaneously.
• normal static methods
• normal instance methods
• synchronized instance methods

Note: Class Level and block level both are different, there is no link between class level and block level. both are independent to each other.

Synchronized Block

The main advantage of synchronized block over synchronized method, it reduces the waiting time of the threads and improves the performance of system.

Inter Thread Communication

• Two threads communicates with each other by using wait( ) notify( ) notifyAll( ) methods. the thread which requires updation it has to call wait( ) and the thread which is responsible to update has to call notify( ) method.
• wait( ) notify( ) notifyAll( ) methods are available in Object class not in thread class, because threads are required to call these method on any shared object.
• If a thread want to call wait( ) notify( ) notifyAll( ) methods, compulsory thread should be owner of the object, which mean the thread has to get lock of that object, the thread should be in the synchronized area. we can call this all methods only from synchronized area.

notify() vs notifyAll()

• We can use notify( ) to notify only one waiting thread, but which waiting thread will get notify we can't expect exactly. all other threads have to wait till further notification.
• But in the case of notifyAll( ) all waiting threads will get notify but threads will be executing one by one.

Deadlock

If two or more threads are waiting for same resources such type of situation is called deadlock, there is no resolution for deadlock but we have several prevention techniques. Synchronized keyword is the only reason for deadlock occurrence.

Deadlock vs Starvation

• In the case of deadlock waiting never ends.
• A long waiting of a thread which ends at certain point of time is called starvation.

Daemon Threads

The threads which are executing in the background known as Daemon Thread eg. Garbage Collector. the main objective of daemon thread is to provide support for non daemon threads, we can check whether the thread is daemon or not by using Daemon( ) method. public final boolean isDaemon( )

We can change daemon nature of a thread by using setDaemon( ) method, but before starting the thread. public final void setDaemon(boolean b)

main thread is always non daemon and it is not possible to change it's daemon nature.

How to Kill a Thread

• A thread can stop or kill another thread by using stop( ) method

Suspending and Resuming Thread

• A thread can suspend another thread by using suspend( ) method
• A thread can resume a suspended thread by using resume( ) method