==============

Multi Threading
==============

Task : Work

Single Tasking : Performing only one task at a time is called as Single Tasking

Ex:

1) Explain the topic

2) Dictate the notes
3) Ask questions

-> If we perform single tasking then it will take lot of time to complete all our
work.

Multi Tasking : Performing multiple tasks at a time is called as Multi Tasking

Ex:

1) Walking & listening music

2) Speaking and Writing

3) Reading book & eating

-> If we perform multi tasking then we complete multiple works at a time.

-> Multi Tasking we can achieve in 2 ways

1) Process Based Multi Tasking

Ex: Windows OS

2) Thread Based Multi Tasking

-> To execute our program logics paralelly then we need to go for Thread Based
Multi Tasking

-> Using Thread Based Multi Tasking our program can complete the work quickly

-> To implement Thread Based Multi Tasking we will use Multi Threading

-> Java Supports Multi Threading

=============================
Use case to go for Multi Threading
=============================

1) Send sms to all customers at a time

2) Send Email to all customers at a time
3) Generate & Send Bank Statements to all customers in email

Note: The main aim of Multi Tasking is used execute our program logic paralelly so
that we can complete more work in less time.
-> For Every Java program execution, JVM will create one thread by default. That
thread is called as Main thread.

// Java Program to get the details of Main thread

public class Demo {

public static void main(String... args) {

Thread currentThread = Thread.currentThread();

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

}
}

Note: Thread is a predefined class available in java.lang package. In Thread class

we have a static method currentThread ( ).

===================
User Defined Threads
===================

-> In Java we can create Thread in 2 ways

1) By extending Thread class

2) By Implementing Runnable interface

// Java program to create user defined thread using Thread class

public class Demo extends Thread {

public void run() {

System.out.println("run () method called...");
}

public static void main(String... args) {

Demo d = new Demo();

Thread t = new Thread(d);

t.start();
}
}

// Java program to create the thread using Runnable interface

public class Demo implements Runnable {

public void run() {

System.out.println("run () method called...");
}

public static void main(String... args) {

 Demo d = new Demo();

Thread t = new Thread(d);

t.start();
}
}

===================================================================================
===============
Q) What is the difference between extending Thread class and implementing Runnable
interface, which is recommended ?
===================================================================================
===============

-> If we extend properties from Thread class then we can't extend properties from
any other class because java doesn't support mulitple inheritence. (We are closing
gate for Inheritence)

-> If we implement Runnable interface then in future we can extend properties from
any class based on requirement. (Our gate is open for inheritence)

Note: Implementing Runnable interface is always recommended.

=======================
What is Thread Schedular
=======================

-> Thread Schedular is a program in the JVM which is responsible to schedule

Threads execution and resources allocation required for the thread.

-> When we call start ( ) method then Thread Schedular will start its operation.

1) Allocating Resources

2) Thread Scheduling

3) Thread Execution by calling run ( ) method

================================
start ( ) method vs run ( ) method
================================

-> To start thread execution we will call start ( ) method

t.start ( )

-> once start ( ) method is called then Thread Schedular will come into picture to
execute our thread

-> start ( ) method will call run ( ) method internally

-> inside run ( ) method we will write the logic which should be executed by the
thread.

=======================================================
Can we call run ( ) method directley without calling start ( ) method
========================================================

-> Yes, we can call run ( ) method directley but it will execute like a normal
method (there is no use) by "main" thread.

-> If we want to execute run ( ) method as a thread method then we should call
start ( ) method then internally it will call run ( ) method (Thread Schedular will
take care of thread execution)

public class Demo implements Runnable {

public void run() {

System.out.println("run () method started...");

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

System.out.println("run () method ended...");

}

public static void main(String... args) {

Demo d = new Demo();

Thread t = new Thread(d);

//t.start();
// t.run();
}
}

=> If we call start ( ) method then run ( ) method will be executed by our user
defined thread (we can see thread name as Thread-0)

=> if we call run ( ) method then run ( ) method will be executed by "main" thread
(we can see thread name as main)

======================
What is Thread Life Cycle
======================

-> Thread Life cycle contains several phases of Thread execution

1) New

2) Runnable

3) Running

4) Blocked

5) Terminated

New: A thread begins its life cycle in the new state. Thread remains in the new
state until we will call start ( ) method.
Runnable : After calling start ( ) method, thread comes from new state to runnable
state.

Running : A thread comes to running state when Thread Schedular will pick up that
thread for execution.

Blocked : A thread is in waiting state if it waits for another thread to complete

its task.

Terminated : A thread enters into terminated state once it completes its task.

// Java Program on Thread Sleep

package in.ashokit;

public class Demo implements Runnable {

public void run() {

System.out.println("run () method started...");

try {
Thread.sleep(5000); // blocked state
} catch (InterruptedException e) {
e.printStackTrace();
}

System.out.println("run () method ended...");

}

public static void main(String... args) {

Demo d = new Demo();

Thread t = new Thread(d); // new state

t.start(); // runnable state
}
}

// Java program to start mutliple threads to perform same activity

package in.ashokit;

public class Demo implements Runnable {

public void run() {

System.out.println("run () method started..." +
Thread.currentThread().getName());
try {
Thread.sleep(15000); // blocked state
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("run () method ended..." +
Thread.currentThread().getName());
}
 public static void main(String... args) {
Demo d = new Demo();

Thread t1 = new Thread(d);

t1.setPriority(Thread.MAX_PRIORITY); // 10
t1.setName("Thread-1");

Thread t2 = new Thread(d);

t2.setPriority(Thread.NORM_PRIORITY); // 5
t2.setName("Thread-2");

Thread t3 = new Thread(d);

t3.setPriority(Thread.MIN_PRIORITY); // 1
t3.setName("Thread-3");

t1.start(); // runnable state

t2.start(); // runnable state
t3.start(); // runnable state
}
}

Note: We shouldn't start one thread more than one time.

public static void main(String... args) {

Demo d = new Demo();

Thread t1 = new Thread(d);

t1.start();
t1.start(); // java.lang.IllegalThreadStateException
}

=================
Callable Interface
=================

-> This interface introduced in java 1.5

-> Using Callable interface also we can create the Thread

-> This interface contains call ( ) method.

Syntax:

public Object call ( )

====================================================
What is the difference between Runnable & Callable interfaces
====================================================

-> Runnable is a functional interface which contains run ( ) method

-> Callable is a functional interface which contains call ( ) method

-> Runnable run ( ) method returns void (no return type)

-> Callable call ( ) method returns Object

-> Runnable interface present in java.lang package

-> Callable interface present in java.util.concurent package

==============================
ExecutorService
==============================

-> Executor Service introduced in java 1.5v

-> Using ExecutorService we can implement multi threading

-> Using Executors we can create thread pool

-> Using Executor Service we can submit tasks to pool of threads.

-> ExecutorService will re-use threads available in the pool to complete all
submitted tasks.

// Java Program on Executor Service with Callable interface

package in.ashokit;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class Demo implements Callable {

public Object call() throws Exception {

System.out.println("call ( ) - method executed...");
return "success";
}

public static void main(String[] args) throws Exception {

Demo d = new Demo();

ExecutorService exService = Executors.newFixedThreadPool(10);

for (int i = 1; i <= 15; i++) {

Future submit = exService.submit(d);
System.out.println(submit.get().toString());
}
exService.shutdown();
}
}

=============
Daemon Thread
=============

We have 3 types of threads in java

1) Default thread created by JVM ( main thread )

2) User Defined Threads ( Thread class, Runnable interface, Callable interface )

3) Daemon Threads

Note: The thread which runs in the background is called as Dameon Thread. Daemon
Threads also called as low priority threads.

Ex: Garbage Collector is a daemon thread

-> We can make our thread as Daemon Thread using setDaemon( ) method

// Java Program To Make thread as Daemon

package in.ashokit;

public class Demo implements Runnable {

@Override
public void run() {

if (Thread.currentThread().isDaemon()) {
System.out.println("Daemon Thread Executed...");
} else {
System.out.println("Normal Thread Executed...");
}

public static void main(String[] args) {

Demo d = new Demo();
Thread t1 = new Thread(d);
t1.setDaemon(true);
t1.start();
}
}

-> When JVM reaches end of main method, it will terminate our program. If JVM
founds Daemon thread running it terminates that daemon thread and then it will
shutdown the program.

-> JVM will not care about Daemon Threads running status to stop the program
execution.

==============
Synchronization
==============

String ----> Immutable class

StringBuffer ----> Mutable class & synchronized class (Thread safe class)

StringBuilder ---> Mutable class & not-synchronized class (Not Thread Safe class)

Synchronized means Thread safe ===> Only one thread can access the object /
resource at a time

Not-Synchronized means Not Thread Safe => Multiple threads can access same
resource / object at a time

public class MovieTicketBooking {

int avilableTickets = 100;

public void run ( ) {

if ( availableTickets > 0 ) {
// logic to bookTicket;
-- avilableTickets ;
}
}

psvm ( ) {
Thread t1 = new Thread();
Thread t2 = new Thread();
Threa t20 = new Thread();

t1..... t20 ---start

}
}

-> In the program, multiple threads are trying to book tickets at a time

Note: If multiple threads access the same object at a time then there is a chance
of getting data inconsistency problem.

=> To avoid data inconsistency problem, we need to use Synchronization concept

=> Synchronization means allowing only one thread to execute our resource /
object / logic at a time

Note: By Using Synchronization we can achieve Thread Safety but it will slow down
our execution process.

===========================
How to achieve synchronization
===========================

-> Using 'synchronized' keyword we can implement synchronization

-> synchronized keyword we can use at two places

1) At method level

2) At block level

--------------------------------------------
Syntax For Synchronized Block:
--------------------------------------------

public void m1( ){

 // pre-logic

synchronized ( object ) {
// imp business logic
}

// post-logic

--------------------------------------------
Syntax For Synchronized Method :
--------------------------------------------

public synchronized void m1( ) {

// important business logic

// Java Program with Synchronized Method

public class Demo implements Runnable {

public synchronized void printNums() {

for (int i = 1; i <= 10; i++) {
System.out.println(Thread.currentThread().getName() + "=> " + i);
try {
Thread.sleep(1000);
} catch (Exception e) {
e.printStackTrace();
}
}
}

public void run() {

printNums();
}

public static void main(String[] args) {

Demo d = new Demo();

Thread t1 = new Thread(d);

t1.setName("Thread-1");
t1.start();

Thread t2 = new Thread(d);

t2.setName("Thread-2");
t2.start();
}
}

Note: In the above program we are starting 2 threads. two threads will access
printNums ( ) method to print the numbers from 1 to 10.

-> If printNums ( ) method having synchronized keyword then two threads will
execute the method sequentially one after other .

-> if we remove synchronized keyword from the printNums ( ) method then two threads
will access that method at a time.

Note: We can see the difference in the output.

==============================================
Working with Threads using Anonymous Implementation
==============================================

package in.ashokit;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class MyThread {

public static void main(String[] args) {

Thread t1 = new Thread() {

public void run() {
System.out.println("run ( ) method logic-1");
}
};
t1.start();

Runnable r = new Runnable() {

@Override
public void run() {
System.out.println("run method() logic-2");
}
};

Thread t2 = new Thread(r);

t2.start();

Callable c = new Callable() {

public Object call() throws Exception {
System.out.println("call( ) method logic - 3");
return null;
}
};

ExecutorService exService = Executors.newFixedThreadPool(1);

exService.submit(c);
}
}

==========
Dead Lock
=========

-> Dead Lock means ambiguity problem among the threads

-> If 2 threads are waiting for each other to release the resources is called as
dead lock.

-> Once we get into dead lock situation then we can't do anything

Ex:
----

Thread-1 holding resource-1 and waiting for resource-2

Thread-2 holding resource-2 and waiting for resource-1

Note:

Thread-1 will not release resource-1 hence thread-2 will be in waiting state
forever for resource-1

Thread-2 will not release resource-2 hence thread-1 will be in waiting state
forever for resource-2

// Java program which will give dead lock

package in.ashokit;

public class DeadLock {

public static void main(String[] args) {

String s1 = "hi";
String s2 = "hello";

Thread t1 = new Thread() {

public void run() {
synchronized (s1) {
System.out.println("Thread-1 locked resource-1");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (s2) {
System.out.println("Thread-1 waiting for
resource-2");
}
}
}
};

Thread t2 = new Thread() {

public void run() {
synchronized (s2) {
System.out.println("Thread-2 locked resource-2");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (s1) {
 System.out.println("Thread-2 waiting for
resource-1");
}
}
}
};
t1.start();
t2.start();
}
}

=============
join ( ) method
=============

-> join ( ) method is used to hold second thread execution until first thread
execution got completed

package in.ashokit;

public class Demo {

public static void main(String[] args) throws Exception {

Thread t1 = new Thread() {

public void run() {
for (int i = 1; i <= 5; i++) {
System.out.println(Thread.currentThread().getName() +
" => " + i);
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
};
t1.setName("Thread-1");

Thread t2 = new Thread() {

public void run() {
for (int i = 1; i <= 5; i++) {
System.out.println(Thread.currentThread().getName() +
" => " + i);
try {
Thread.sleep(100);
Thread.yield();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
};
t2.setName("Thread-2");

t1.start();
t1.join();
 t2.start();
}
}

==============
yield ( ) method
===============

-> yield ( ) method is used to give chance for other equal priority threads to
execute

// Java program with yield ( ) method

package in.ashokit;

public class YieldDemo {

public static void main(String[] args) {

Thread producer = new Producer();
Thread consumer = new Consumer();

producer.start();
consumer.start();
}
}

class Producer extends Thread {

public void run() {
for (int i = 0; i < 3; i++) {
System.out.println("Producer : Produced Item " + i);
Thread.yield();
}
}
}

class Consumer extends Thread {

public void run() {
for (int i = 0; i < 3; i++) {
System.out.println("Consumer : Consumed Item " + i);
Thread.yield();
}
}
}

========================
Inter Thread Communication
========================

-> It is used to establish communication among the threads

-> To achieve inter thread communication we have below 3 methods in Object class

1) wait ( )
2) notify ( )
 3) notifyAll ( )

Q) Why these 3 methods available in Object class, why not in Thread class ?

-> If these methods available in Thread class then we have to extend Thread class.
In future we can't extend from any other java class bcz java is against for
Multiple Inheritence.

-> If these methods available in Runnable interface then everybody should implement
these method even if they don't need inter thread communication.

-> To overcome all these problems, java kept these methods in Object class so that
every class will have access for these methods.

// Java Program to establish inter thread communication

package in.ashokit;

public class Customer {

int amount = 10000;

synchronized void withdraw(int amount) {

System.out.println("going to withdraw...");
if (this.amount < amount) {
System.out.println("Less balance; waiting for deposit...");
try {
wait();
} catch (Exception e) {
}
}
this.amount -= amount;
System.out.println("withdraw completed...");
}

synchronized void deposit(int amount) {

System.out.println("going to deposit...");
this.amount += amount;
System.out.println("deposit completed... ");
notify();
}

public static void main(String args[]) {

final Customer c = new Customer();

new Thread() {
public void run() {
c.withdraw(15000);
}
}.start();

try {
Thread.sleep(20000);
} catch (InterruptedException e) {
e.printStackTrace();
}
 new Thread() {
public void run() {
c.deposit(10000);
}
}.start();
}
}

================================
Multi Threading Summary
=================================
1) What is Multi Tasking
2) What is Multi Threading
3) Advantages of Multi Threading
4) Default Thread in JVM (main)
5) Getting info of main thread ( Thread.currentThread( ) )
6) Creating User Defined Threads
7) By Extending Thread class
8) By Implementing Runnable interface
9) By implementing Callable interface
10) run ( ) method vs call ( )
11) Executor Service
12) run ( ) vs start ( ) method
13) Thread Life Cycle
14) Thread Schedular
15) Synchronization (method & block)
16) What is Thread Safety
17) Thread creation with Anonymous implementation
18) Dead Lock (Java Program to give dead lock)
19) join ( ) method vs yield ( ) method
20) Inter Thread Communication
21) Daemon Threads