==============
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