01 Exception-Handling 02 Exception Types,

TOPIC Fundamentals TOPIC Using try catch

03 throw throws and finally 04 Built-in Exceptions,

keywords Creating own exception
TOPIC TOPIC subclasses

05 Multithreading: Life cycle of 06 creating threads,

a thread thread priorities
TOPIC TOPIC

07 08
Synchronizing threads Interthread
TOPIC TOPIC Communication.
 Exception-Handling Fundamentals
 An exception is an abnormal condition that arises in a code at run time. In other words, an exception is a
runtime error.
 When an Exception occurs the normal flow of the program is disrupted and the program/Application
terminates abnormally, which is not recommended, therefore these exceptions are to be handled.
 An exception can occur for many different reasons, below given are some scenarios where exception
occurs.
i. Division by zero
ii. Array out of bound access exception
iii. A user has entered invalid data.
iv. A file that needs to be opened cannot be found.
v. A network connection has been lost in the middle of communications

 Some of these exceptions are caused by user error, others by programmer error, and others by physical
resources that have failed in some manner.
 Exception-Handling
 “Exception handling is the mechanism to handle run time errors, so that the normal flow of application can
be maintained.”
 Exception Handling is managed by using 5 Keywords.
1. try
2. catch
3. throw
4. throws
5. finally
Types of Java Exceptions
There are mainly three types of exceptions:
i. User Defined Exceptions
ii. Built in Exceptions
i. Checked Exception
ii. Unchecked Exception
 Types of Exceptions
[Link] exceptions:
 A checked exception is an exception that occurs at the compile time, these are also called as compile
time exceptions.
 These exceptions cannot simply be ignored at the time of compilation, the Programmer should take care
of (handle) these exceptions.
 For example, if you use FileReader class in your program to read data from a file, if the file specified in
its constructor doesn't exist, then an FileNotFoundException occurs, and compiler prompts the
programmer to handle the exception.
 [Link] exceptions
1. ClassNotFoundException: This exception is thrown when the JVM tries to load a class, which is not
present in the classpath.
[Link]("[Link]
er");

2. FileNotFoundException: This exception is thrown when the program tries to access a file that does not
exist or does not open. This error occurs mainly in file handling programs.

File file = new File("E:// [Link]");

FileReader fr = new
FileReader(file);
 [Link] exceptions
[Link]: This exception is thrown when the input-output operation in a program fails or is interrupted
during the program’s execution.
BufferedReader br = new BufferedReader(fr); String line;
while ((line = [Link]()) != null) { // May cause
IOException
[Link](line);

[Link]: This exception occurs whenever a thread is processing, sleeping or waiting in a

multithreading program and it is interrupted.

Thread t = new
Thread();
[Link](10000);
 Types of Exceptions
import [Link];
import [Link];
public class FilenotFound_Demo
{
public static void main(String args[])
{
File file=new File("E://[Link]");
FileReader fr = new FileReader(file);
}

}
If you try to compile the above program you will get exceptions as shown below.
C:\>javac FilenotFound_Demo.java
FilenotFound_Demo.jav[Link] error: unreported exception FileNotFoundException; must be caught or declared
to be thrown
FileReader fr = new FileReader(file);
^
1 error
Some of the examples of checked exceptions
 Types of Exceptions
[Link] exceptions:
 An Unchecked exception is an exception that occurs at the time of execution, these are also called as
Runtime Exceptions.
 These include programming bugs, such as logic errors or improper use of an API.
 Runtime exceptions are ignored at the time of compilation.
 For example, if you have declared an array of size 5 in your program, and trying to call the 6th element of
the array then an ArrayIndexOutOfBoundsException occurs.
 To guard against and handle a run-time error, simply enclose the code that you want to monitor inside a
try block.
 Immediately following the try block, include a catch clause that specifies the exception type that you
wish to catch.
 [Link] exceptions
[Link]: This exception occurs when a program encounters an error in arithmetic operations
class Test
such as divide by zero. {
public static void OUTPUT
main(String[] args) D:\>java Test
{ Exception in thread "main"
[Link]: /
[Link](120/0); by zero
}
}
[Link]: This exception is thrown when an array is accessed using an illegal
index. The index usedclass
is either more than the size of the array or is a negative index. Java doesn’t support
Test
negative indexing. {
public static void OUTPUT
main(String[] args) D:\>java Test
{ Exception in thread "main"
int[] a = {10,20,30}; [Link]
dsException: Index 50 out of
[Link](a[50]); bounds for length 3
}
 [Link] exceptions
[Link]: This exception is raised when a null object is referred to in a program.
NullPointerException
class Test is the most important and common exception in Java.
{
OUTPUT
public static void
D:\>java Test
main(String[] args)
Exception in thread "main"
{
[Link]:
String s = null;
Cannot invoke "[Link]()" because
"<local1>" is null
[Link]([Link]());
at [Link]([Link])
}
}
[Link]:class
This Test
exception is thrown when a method could not convert a string
{
into a numeric format.
public static void
main(String[] args)
{
String a = "abc";
int
num=[Link](a);
}
 [Link] exceptions
5. StringIndexOutOfBoundsException: This exception is thrown by the string class, and it indicates that the
index is beyond the size of the string object or is negative.
class Test
{
public static void main(String[] args)
{
String a = "JAVA";
char c = [Link](6); // accessing 6
index element
[Link](c);
}
}

eg: InputMismatchException, NegativeArraySizeEXception,...

[Link] exceptions
 Printing Exception information
The following are the methods to fetch exception information:
i. [Link]() ---------------> Name of the Exception: Description -> StackTrace
ii. [Link]() -----------------> Name of the Exception: Description
iii. [Link]() -----------> Description
class Test class Test class Test
{ { {
public static void main(String[] args) public static void main(String[] args) public static void main(String[] args)
{ { {
int a[] = {11,22}; int a[] = {11,22}; int a[] = {11,22};
try try try
{ { {
[Link](a[9]); [Link](a[9]); [Link](a[9]);
} } }
catch (Exception e) catch (Exception e) catch (Exception e)
{ { {
[Link]();
[Link]([Link]()); [Link]([Link]());
}
} }
}
} }
}
} }
[Link]
n: Index 9 out of bounds for length 2 [Link] Index 9 out of bounds for length 2
at [Link]([Link]) n: Index 9 out of bounds for length 2
 USING TRY AND CATCH
 This is the general form of an exception-handling block:

try
{
// block of code to monitor for errors
}
catch (ExceptionType1 exOb)
{
// exception handler for ExceptionType1
}
finally
{
// block of code to be executed after try block ends
}
 USING TRY AND CATCH
 ExceptionType is the type of exception that has occurred.
 Program Statements that we monitor for exceptions are contained in try block.
 If an exception occurs in try block, it is thrown.
 The code can catch this exception using catch block and handle the exception in a rational manner.
 System generated exceptions are automatically thrown by the Java runtime.
 Catch block is used to handle the exception, called Exception Handler.
 Must be used after try block only. We can use multiple catch blocks with a single try block.
 The throw keyword is used to manually throw an exception
 Any code that absolutely must be executed after a try block completes is put in finally block.
class Exc2
{
public static void main(String args[])
{
int d, a;
try
{
d = 0;
a = 42 / d;
[Link]("This will not be printed.");
}
catch (ArithmeticException e)
{
[Link]("Division by zero.");
} Output
[Link]("After catch statement."); Division by zero.
After catch statement
}
}
 MULTIPLE CATCH CLAUSES
 In some cases, more than one exception could be raised by a single piece of code.
 To handle this type of situation, you can specify two or more catch clauses, each catching a different
type of exception.
 When an exception is thrown, each catch statement is inspected in order, and the first one whose type
matches that of the exception is executed.
 After one catch statement executes, the others are bypassed, and execution continues after the
try/catch block. try
{
 Syntax of Multiple catch statements: // block of code to monitor for errors
}
catch (ExceptionType1 exOb)
{
// exception handler for ExceptionType1
}
catch (ExceptionType2 exOb)
{
// exception handler for ExceptionType2
}
// ...
 MULTIPLE CATCH CLAUSES
// Demonstrate multiple catch statements.
class MultiCatch {
public static void main(String args[])
{
try
{
int a = [Link];
[Link]("a = " + a); Output
int b = 42 / a; a = 10
int c[] = { 1 }; Array index oob:
c[42] = 99; [Link]:
} Index 42 out of bounds for length 1
catch(ArithmeticException e) After try and catch blocks.
{
[Link]("Divide by 0: " + e);
}
catch(ArrayIndexOutOfBoundsException e)
{
[Link]("Array index oob: " + e);
}
[Link]("After try and catch blocks.");
}
}
 NESTED TRY STATEMENTS
 The try statement can be nested.
 That is, a try statement can be inside the block of another try.
 Each time a try statement is entered, the context of that exception is pushed on the stack.
 If an inner try statement does not have a catch handler for a particular exception, the stack is unwound
and the next try statement’s catch handlers are inspected for a match.
 This continues until one of the catch statements succeeds, or until the entire nested try statements are
exhausted.
 If no catch statement matches, then the Java run-time system will handle the exception. Here is an
example that uses nested try statements:
// An example of nested try statements.
class NestTry
{
public static void main(String args[])
{
try
{
int a[] = {1,2,3,0,4};
try
{
int b=a[2]/a[3];
}
OUTPUT:
catch(ArithmeticException e)
C:\>java NestTry
{ [Link]: / by zero
[Link]( e); [Link]
}
a[20]=44;

}
catch(ArrayIndexOutOfBoundsException e)
{
[Link](e);
}
}}
 THROW
 So far, you have only been catching exceptions that are thrown by the Java run-time system.
 However, it is possible for your program to throw an exception explicitly, using the throw statement
 throw keyword is used to explicitly throw an exception from a method or constructor.
 We can throw either checked or unchecked exceptions in java by throw keyword.
 The "throw" key-word is mainly used to throw a custom exception.
 When a throw statement is encountered, program execution is halted, and the nearest catch statement is
searched for a matching kind of exception.
 The general form of throw is shown here: Syntax
throw
ThrowableInstance;
Here, ThrowableInstance must be an object of type Throwable or a subclass of Throwable.

Example-1 Example-2
throw new throw new ArithmeticException(“Something
ArithmeticException( ); went wrong!”);
// Demonstrate throw.
class Test
{
static void avg()
{
try
{
throw new ArithmeticException("demo");
}
catch(ArithmeticException e)
{
[Link]("Exception caught“+e);
}
}

public static void main(String args[])

{
avg();
} Output
} Exception [Link]: demo
import [Link];
class Test Output
{ Please enter your roll number
public static void main(String[] args)
1201
{
Scanner s = new Scanner([Link]); Valid roll number
[Link]("Please enter your roll number");
int roll = [Link]();
try
{
if (roll < 0)
{
throw new ArithmeticException("The number entered is not positive");
}
else
{
[Link]("Valid roll number");
}
}
catch (ArithmeticException e) Output
{ Please enter your roll number
[Link]("An exception is thrown"); -27
[Link]([Link]()); An exception is thrown
} The number entered is not positive
 THROWS
 In Java,Methods may throw exceptions during the execution of the program using the throws keyword.
 The throws keyword is used to declare the list of exception that a method may throw during execution
of program.
 so that anyone calling that method gets a prior knowledge about which exceptions are to be handled.
 This is the general form of a method declaration that includes a throws clause:

Syntax
<return_type> <method_name> ( ) throws <excpetion_name1>, <exception_name2>
{
// body of method
}
Example
void Display( ) throws ArithmeticException, NullPointerException
{
//code
}
class Test
{
static void check() throws ArithmeticException
{
[Link]("Inside check function");
throw new ArithmeticException("demo");
}

public static void main(String args[])

{
try OUTPUT
{ Inside check function
check(); [Link]: demo
}
catch(ArithmeticException e)
{
[Link]("caught" + e);
}
}
}
DIFFERENCE BETWEEN THROW AND THROWS IN JAVA
 FINALLY
 A finally keyword is used to create a block of code that follows a try block.
 A finally block of code is always executed whether an exception has occurred or not.
 Using a finally block, it lets you run any cleanup type statements that you want to execute.
 A finally block appears at the end of catch block.
Syntax
try
{
Syntax statement1;
try statement2;
{ }
statement1; catch(Exceptiontype
statement2; e1)
} {
finally statement3;
{ }
statements; finally
} {
statement4;
}
// Demonstrate finally.
class Demo
{
public static void main(String[] args)
{
int a[] = new int[2];
try
{
[Link]("Access invalid element"+ a[3]);
}
catch(ArrayIndexOutOfBoundsException e)
{
[Link]("Exception caught");
}
finally
OUTPUT
{ Exception caught
[Link]("finally is always executed."); finally is always executed.
}
}
}
// Demonstrate finally. public static void main(String args[])
class FinallyDemo {
{ try
static void procA() {
{ procA();
try }
{ catch (Exception e)
[Link]("inside procA"); {
throw new RuntimeException("demo"); [Link]("Exception caught");
} }
finally procB();
{ }
[Link]("procA's finally"); }
}
}
static void procB()
{
try
{ OUTPUT
[Link]("inside procB"); inside procA
return; procA’s finally
} Exception caught
finally inside procB
{ procB’s finally
[Link]("procB's finally");
}
}
 Creating own exception
 Java allows us to create our own exception class to provide own exception implementation.
 These type of exceptions are called user-defined exceptions or custom exceptions.
 You can create your own exception simply by extending java Exception class.
 You can define a constructor for your Exception (not compulsory) and you can override the toString()
function to display your customized message on catch.

Syntax
class <name of the class> extends Exception
{
public String toString()
{
Statements;
}
}
 Creating own exception
Example
class MyException extends Exception
{ class Test
String str1; {
MyException(String s) public static void main(String args[])
{ {
str1=s; try
} {
public String toString() [Link]("Starting of try block");
{ throw new MyException("This is My error Message");
return ("MyException Occurred: "+str1) ; }
} catch(MyException exp)
} {
[Link]("Catch Block") ;
[Link](exp) ;
}
OUTPUT
}
Starting of try block
Catch Block }
MyException Occurred: This is My error Message
 Example
class InsufficientFundsException extends Exception else
{ throw new InsufficientFundsException("No Balance in your account");
InsufficientFundsException(String s) }
{ catch (InsufficientFundsException e)
super(s); {
} [Link]([Link]());
} }
class Test finally
{ {
public static void main(String[] args) [Link]("Updated Balance:"+balance);
{ [Link]("Pls take your card");
[Link] obj = new }
[Link]([Link]); }
double balance = 10000.00; }
double amt = [Link]();
try
{
if(amt<=balance)
{
[Link]("pls take the cash");
OUTPUT
balance = balance - amt;
}
 Multi Threading
 Multi Threading is a specialized form of multi tasking.
 Multitasking is a process of executing multiple tasks simultaneously. We use multitasking to utilize the
CPU. Multitasking can be achieved in two ways:
 Process-based Multitasking (Multiprocessing)
 Thread-based Multitasking (Multithreading)
 Executing several tasks simultaneously where each task is a separate independent process such type of
multitasking is called process 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 a "Thread"
 Multithreading refers to a process of executing two or more threads simultaneously for maximum
utilization of the CPU.
 Multithreading is a feature in Java that concurrently executes two or more parts of the program.
 Multi Threading
 A thread in Java is a lightweight process requiring fewer resources.
 Each thread runs parallel to each other. A thread is a lightweight subprocess,
the smallest unit of execution within a
 Java Provides built in support for multi threaded programming. program.
It allows multiple parts of a program
 Threads share common memory area. to run concurrently
 A main program is also single thread.
Advantages of MultiThreading
 Allows to write very efficient program that makes maximum use of CPU.
 Throughput – Amount of work done in unit time increase.
 It is used to save time as multiple operations are performed concurrently.
 The threads are independent, so it does not block the user to perform multiple operations at the same
time.
 Since threads are independent, other threads don’t get affected even if an exception occurs in a single
thread.
• Multi Threading : It allows concurrent execution of two or
more parts of a program for maximum utilization of CPU.

• Each part of such program is called a thread.

 Thread Life Cycle
 The life cycle of a thread in Java is controlled by JVM.
 During the execution of thread, it is in any of the following five states.
 Hence Java thread life cycle is defined in five states.

run()

start()
 Thread Life Cycle
i. New: The thread is in new state when the instance of thread class is created but before the calling of start()
method.
ii. Runnable: The thread is in runnable state after the invocation start() method, but the thread scheduler has
not selected it to be the running thread. Any number of threads exists in this state.
iii. Running: The thread is in running state when the thread scheduler selects a thread for execution.
iv. Waiting/blocked/sleeping: this is the state when the thread is still alive but is not eligible currently to run.
v. (Blocked) Terminated: A thread is in terminated or dead state when its run() method exits.
 We can define a Thread in the following 2 ways.
i. By extending Thread class.
ii. By implementing Runnable interface
Thread class :
 Multi Threading
 The main important application areas of multithreading are:
 To implement multimedia graphics.
 To develop animations.
 To develop video games etc.
 To develop web and application servers.
Thread class:
 Java provides Thread class to achieve thread programming.
 Thread class provides constructors and methods to create and perform operations on a thread.
 Commonly used Constructors of Thread class:

i. Thread() ii. Thread(String name)

iii. Thread(Runnable r) iv. Thread(Runnable r, String name)
 Commonly used methods of Thread class
 Commonly used methods of Thread class:
1. public void start():
 starts the execution of the thread. start() method of Thread class is used to start a newly created thread.

It performs following tasks:

1. A new thread starts
2. The thread moves from New state to the Runnable state.
3. When the thread gets a chance to execute, its target run() method will be called and executes.
2. public void run(): It is the entry point of a thread , used to perform action for a thread.
3. public int getPriority(): It returns the priority of the thread.
4. public int setPriority(int priority): It is used to set or change the priority of the thread.
5. public String getName(): It returns the name of the thread.
 Commonly used methods of Thread class
6. public void setName(String name): It is used to set or change the name of the thread.

[Link] static Thread currentThread(): returns the reference of currently executing thread.

8. Public static void sleep(long miliseconds): Causes the currently executing thread to suspend (temporarily

cease execution) for the specified number of milliseconds.

9. public void join(): waits for a thread to die/terminate.

[Link] boolean isAlive(): to check the thread is still running. Returns true if the thread is still running.

[Link] void yield(): causes the currently executing thread object to temporarily pause and allow other

threads to execute.

[Link] [Link] getState(): returns the state of the thread.

 Creating Thread – Extending Thread Class
Step-1:

Create a new class that extends Thread, and then create an instance of that class.
Step-2:

The extending class must override the run () method, which is the entry point of the
new thread created. The actual code for the thread to execute is provided. Once the run ()
method completes, the thread will die and terminate.
Step-3:

Calls start () method to begin execution of new thread.

Step-4:

Invoke the Thread class constructor using super keyword if necessary.

 Creating Thread – Extending Thread Class
class MyThread extends Thread
{
public void run()
{
for(int i=0;i<5;i++)
{ OUTPUT
[Link]("Child Thread"); main thread
} main thread
} main thread
} main thread
public class TheadDemo1 main thread
{ Child Thread
public static void main(String[] args) Child Thread
{ Child Thread
MyThread t1 = new MyThread(); Child Thread
[Link](); Child Thread
for(int i=0;i<5;i++)
{
[Link]("main thread");
}
}
}
 Creating Thread – Implementing Runnable Interface
Step-1:
To create a new Thread, the class must implements Runnable interface.
Step-2:
Provide implementation for the only one method run (), which is the entry point of newly created
thread. The actual code for the thread to execute is provided. Once the run () method completes, the thread
will die and terminate.
Step-3:
Instantiate an object of type Thread within the newly created thread class. Thread(Runnable obj ,
String name)
Step-4:
call the start () method explicitly to start the thread. It makes a call to run() method to start the
execution.
 Creating Thread – Implementing Runnable Interface
class MyRunnable implements Runnable
{
public void run()
{
for(int i=0;i<5;i++) OUTPUT
{ [Link]("Child Thread"); main thread
} main thread
} main thread
} main thread
class ThreadDemo main thread
{ Child Thread
public static void main(String[] args) Child Thread
{ Child Thread
MyRunnable r=new MyRunnable(); Child Thread
Thread t=new Thread(r);//here r is a Target Runnable Child Thread
[Link]();
for(int i=0;i<10;i++)
{[Link]("main thread");
}
}
}
 Creating Mutliple Threads public class Own
{
using Thread class
//Multithreading By Extending Thread class
public static void main(String[] args)
{
class MyThread extends Thread
{ Thread t = [Link]();
public void run() [Link]("ID:"+t);
{ [Link]("Name:"+[Link]());
for(int i=0;i<3;i++) [Link]("Vardhaman");
{ [Link](“After renaming:"+[Link]());
[Link](i); MyThread t1 = new MyThread();
try [Link]();
{ try
[Link](1000); {
} [Link]();
catch(Exception e) } OUTPUT
{ catch(Exception e) ID:Thread[#1,main,5,main]
Name:main
{ [Link](e); } After renaming:Vardhaman
[Link](e); MyThread t2 = new MyThread(); 0
} [Link](); 1
} 2
0
} } 1
} } 2
//Multithreading By Extending Thread class
class NewThread extends Thread
Creating Mutliple Threads
{ using Thread class
NewThread(String threadname)
{
super(threadname);
[Link]("Child Thred -> " +this );
}
public void run()
{
try
{
for(int i = 5; i > 0; i--){
[Link](getName ()+ ": " + i);
sleep(500);}
}
catch (InterruptedException e)
{
[Link](getName() + "Interrupted");
}
[Link](getName() + " Completed");
}}
class MultiThread1
{
Creating Mutliple Threads
public static void main(String args[]) using Thread class
{ OUTPUT
Thread t = [Link](); Name is --->main
Main ---> Thread[#1,main,5,main]
[Link]("Name is --->" +[Link]()); Child Thred -> Thread[#21,One,5,main]
[Link]("Main ---> " +t); Child Thred -> Thread[#22,Two,5,main]
Child Thred -> Thread[#23,Three,5,main]
NewThread t1 = new NewThread("One");
Main Thread->1
NewThread t2= new NewThread("Two"); One: 5
NewThread t3 = new NewThread("Three"); Three: 5
Two: 5
[Link](); Main Thread->2
[Link](); Two: 4
Three: 4
[Link]();
One: 4
try One: 3
{ Main Thread->3
Two: 3
for(int n=1;n<=5;n++){ Three: 3
[Link]("Main Thread->" +n); One: 2
[Link](500);} Main Thread->4
Two: 2
} Three: 2
catch (InterruptedException e) Three: 1
Two: 1
{ Main Thread->5
[Link]("Main thread Interrupted"); One: 1
} One Completed
Main thread Completed
[Link]("Main thread Completed"); Two Completed
}} Three Completed
class NewThread implements Runnable
{ Creating Mutliple Threads
Thread t;
NewThread() using Runnable Interface
{
t = new Thread(this, "Child Thread");
[Link]("Child thread: " + t);
[Link]("The thread name is "+[Link]());
[Link]();
}
public void run()
{
try
{
for(int i = 1; i <=10; i++)
{
[Link]("Child Thread: ->" + [Link]() + ":" + i);
[Link](500);
}
}
catch (InterruptedException e)
{
[Link]("Child interrupted.");
}}}
 Creating Mutliple Threads
public class MultiThread2
{
using Runnable Interface
public static void main(String args[ ] )
{
NewThread t1 = new NewThread();
NewThread t2 = new NewThread();
NewThread t3 = new NewThread();
try
{
for(int i = 5; i > 0; i--) {
[Link]("Main Thread: " + i);
[Link](1000);
}
}
catch (InterruptedException e){
[Link]("Main thread interrupted.");
}
}
}
 Thread Priorities
 Thread priorities are used by the thread scheduler to decide which thread should be allowed to run.
 A higher-priority thread get more CPU time than lowerpriority thread.
 Thread class defines the method setPriority() to assign priority to a thread.
 final void setPriority(int level) The value of level must be within the range MIN_PRIORITY and
MAX_PRIORITY. Currently, these values are 1 and 10, respectively.
 To return a thread to default priority, specify NORM_PRIORITY, which is currently 5.
 These priorities are defined as static final variables within Thread.

public static final int MIN_PRIORITY (1)

public static final int MAX_PRIORITY (10)
public static final int NORM_PRIORITY (5)
 To obtain the current priority setting by calling the getPriority( ) method of Thread class is used.
 Thread Priorities
class NewThread extends Thread
{ NewThread(String name)
{ super (name);
}
public void run()
{ [Link]("Hello -->"+ getName() + "->"+getPriority() ); }
}
public class PriorityDemo
{
public static void main(String args[])
{ OUTPUT
Thread t = [Link](); The main thread priority is : 5
[Link]("The main thread priority is: " +[Link]()); Hello -->Two->10
NewThread t1 = new NewThread("One"); Hello -->Three->5
NewThread t2 = new NewThread("Two"); Hello -->One->1
NewThread t3 = new NewThread("Three");
[Link](Thread.MIN_PRIORITY);
[Link](Thread.MAX_PRIORITY);
[Link](5);
[Link]();
[Link]();
[Link]();
}
}
• join() is about waiting for threads to complete.
• Synchronization is about controlling access to shared resources
(e.g., a seat, a bank account, a file, etc.).

• Only join() — when you just need to wait.

• Only synchronized — when threads work at the same time but need
safe access.
• Both — if you want threads to work safely and the main thread to
wait for them.
Synchronizing: is needed in Java to:
• Prevent data inconsistency
• Avoid race conditions
• Ensure atomic operations
• Maintain data integrity in multithreaded programs
 Synchronizing Threads
 When two or more threads need access to a shared resource, they need some way to ensure that the
resource will be used by only one thread at a time. The process by which this is achieved is called
synchronization.
 Java provides unique, language-level support for it.
 Synchronization allows only one thread to access a shared resource.
 The advantages of Synchronization are:
 To prevent thread interferences.
 To prevent inconsistency of data.
 Thread Synchronization can be of two forms

i. Mutual Exclusion
ii. Inter Thread communication.
 Synchronizing Threads
1. Mutual Exclusion
Keeps threads away from interfering with one another while sharing data. Allows only one thread to access
shared data. Mutual exclusive threads can be implemented using
i) Synchronized Method ii) Synchronized Block
i) Synchronized Method
 A method defines as synchronized, then the method is a synchronized method.
 Synchronized method is used to lock an object for any shared resource.
 When a thread invokes a synchronized method, it automatically acquires lock for that object and releases it
when the thread completes its task. The form of synchronized method is:
class Table
{
synchronized type methodName(arguments)
{
//method body for Synchronization
}
}
Bus Reservation System using synchronization:
1. Multiple passengers (threads) try to book seats on the bus
simultaneously.
2. Without synchronization, two threads could book the same seat,
causing conflicts.
3. Using synchronized methods or blocks, only one thread can access
the booking process at a time.
4. This ensures that the seat availability is checked and updated
atomically for each passenger.
5. Synchronization prevents race conditions and maintains data
consistency in the reservation system.
//synchronized Method - for Synchronization Synchronizing Threads
class Table OUTPUT
{
8x1=8
synchronized void printTable(int n) class MyThread2 extends Thread
{ { 8x2=16
try{ Table t; 8x3=24
for(int i=1;i<=10;i++) MyThread2(Table t) 8x4=32
{ {
[Link](n+"x"+i+"="+n*i); this.t=t;
8x5=40
[Link](1000); } 8x6=48
} public void run() 8x7=56
} { 8x8=64
catch(InterruptedException e) [Link](9);
{ [Link](e); } 8x9=72
} } 8x10=80
} public class SyncDemo1 9x1=9
} {
9x2=18
class MyThread1 extends Thread public static void main(String args[])
{ { 9x3=27
Table t; Table obj = new Table(); 9x4=36
MyThread1(Table t) MyThread1 t1=new MyThread1(obj); 9x5=45
{ MyThread2 t2=new MyThread2(obj);
this.t=t; [Link]();
9x6=54
} [Link](); 9x7=63
public void run() } 9x8=72
{ } 9x9=81
[Link](8);
} 9x10=90
}
 Synchronizing Threads
ii) Synchronized Block:
 Synchronized block can be used to perform synchronization on any specific resource of a method.
 Synchronized block is used to lock an object for any shared resource.
 Scope of Synchronized block is smaller than the method.

The form of synchronized block

is
synchronized(object)
{
//Statements to be synchronized
}
//Thread Synchronization using - synchronized block
class Table
Synchronizing Threads
{
void printTable(int n)
class MyThread2 extends Thread
{
{
[Link]("*****Hello -not synched");
Table t;
synchronized(this)
MyThread2(Table t){
{
this.t=t;
for(int i=1;i<=10;i++)
}
{
public void run()
[Link](n*i);
{
try{ [Link](1000); }
[Link](100);
catch(InterruptedException e)
}
{
}
[Link](e);
public class SyncDemo2
}
{
}
public static void main(String args[])
} //end of sync block
{
[Link]("Hello -not synched");
Table obj = new Table();
} //end of the method
MyThread1 t1=new MyThread1(obj);
}
MyThread2 t2=new MyThread2(obj);
class MyThread1 extends Thread
[Link]();
{ Table t;
[Link]();
MyThread1(Table t){
}
this.t=t;
}
}
public void run() {
[Link](5);
}}
 Synchronizing Threads
//Thread Synchronization using - synchronized block class MyThread1 extends Thread
class Table {
{ Table t;
void printTable(int n) MyThread1(Table t)
{ {
[Link]("Hello -not synched"); this.t=t;
synchronized(this) }
{ public void run()
for(int i=1;i<=10;i++) {
{ [Link](5);
[Link](n*i); }
try }
{ class MyThread2 extends Thread
[Link](1000); {
} Table t;
catch(InterruptedException e) MyThread2(Table t)
{ {
[Link](e); this.t=t;
} }
} public void run()
} //end of sync block {
[Link]("Hello -not synched"); [Link](100);
} //end of the method }
} }
 InterThread Communication
 Inter thread communication or cooperation is allowing synchronized threads to communicate with each
other.
 Interthread communication is a mechanism in which a thread is paused running in its critical section
(synchronized block) and another thread is allowed to enter into the same section.
 Eg: Producer-Consumer Problem.
 Java Provides Interthread communication by using three methods of Object class.

i. wait()
ii. notify()
iii. notifyAll()
 All the three methods must be called only from within a synchronized context.
 All these methods are related to lock and the object has a lock.
 InterThread Communication
i. wait():
 Tells the calling thread to given up the monitor(lock) and go to sleep until some other thread enters
the same monitor and calls notify().
 public final void wait() throws InterruptedException
 public final void wait(long time) throws InterruptedException

Causes current thread to wait until another thread invokes the notify() method or the notifyAll() method
for this object.
 InterThread Communication
•ii. notify():
 wakes up a single thread that is waiting on this object's monitor. If many threads
are waiting on this object, one of them is chosen to be awakened.
 The choice is arbitrary and occurs at the discretion of the implementation. A
thread waits on an object's monitor by calling one of the wait methods.
 public final void notify()
•[Link]()
 wakes up all thread called wait() on the same object. One of the thread will be
granted access. Wakes up all the waiting threads.
 public final void notifyAll()
 Producer Consumer Problem for Interthread Communication

 Producer Thread- Produce items to Buffer (Add Items) Consumer Thread- Consume
items from Buffer (Removes Items).
 The two conditions for Producer – Consumer Problem is
1. Producer cannot add an item into a buffer if it is full
2. Consumer cannot consume an item if it is empty.
 If no communication, these two conditions are not satisfied then the CPU is always in
polling (loop).
 To Save CPU time in Java Interthread communication is used.
 Producer Consumer Problem
//Producer-Consumer problem ---> Inter Thread Communication.
for Interthread Communication
class Buffer
{
int item; synchronized int consume()
boolean produced = false; {
synchronized void produce(int x) if(!produced)
{ {
if(produced) try{
{ wait();
try{ }
wait(); catch(InterruptedException ie)
} {
catch(InterruptedException ie) [Link]("Exception Caught " +ie);
{ }
[Link]("Exception }
Caught"); [Link]("Consumer - Consumed " +item);
} produced = false;
} notify();
item =x; return item;
[Link]("Producer - Produced-->" +item); }
produced =true; }
notify();
}
 Producer Consumer Problem for Interthread Communication
class Consumer extends Thread
{
class Producer extends Thread Buffer b;
{ Consumer(Buffer b)
Buffer b; {
Producer( Buffer b) this.b = b;
start();
{
}
this.b = b; public void run()
start(); {
} [Link]();
public void run() [Link]();
{ [Link]();
[Link](10); [Link]();
[Link](20); }
}
[Link](30);
public class PCDemo
[Link](40); {
[Link](50); public static void main(String args[])
} {
} Buffer b = new Buffer(); //Synchronized Object
Producer p = new Producer(b);
Consumer c = new Consumer(b);
}
}
 N
H A ‘Q
T
’