Session -19

After the completion of the session student will be able to

1. Understand Exceptions and keywords for

Exception Handling.

Problem Solving Assignment

QUIZ-6: Sessions-14, 15, 16.
 Introduction to Exception Handling
 An exception is an abnormal condition that arises in a code
sequence at run time. In other words, an exception is a runtime
error.

 An exception is an event that disrupts the normal flow of the

program.

 In Java Exception is an object which is thrown at run time.

 The exceptions can be
 Division by zero
 Array out of bound access exception
 End of file access etc.

Exception Handling:

“Exception handling is the mechanism to handle run time errors, so

that the normal flow of application can be maintained.”

Java’s exception handling brings run-time error management into the

object-oriented world.

Java Exception Handling is managed by using 5 Keywords.

1. try
2. catch
3. throw
4. throws
5. finally
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
}
catch (ExceptionType2 exOb) {
// exception handler for ExceptionType2
}
// ...
finally {
// block of code to be executed after try block ends
}
ExceptionType is the type of exception that has occurred.

1. Program Statements that we monitor for exceptions are

contained in try block.
2. 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.
3. The throw keyword is used to manually throw an exception
4. Any exception that is thrown out of a method be specified using
throws clause.
5. Any code that absolutely must be executed after a try block
completes is put in finally block.
Uncaught Exceptions

When we don’t handle an exception in a Java Program

class Excep1
{
public static void main(String args[])
{
int d = 0;
int a = 42 / d;
}
}

When the Java run-time system detects the attempt to divide by zero,
it constructs a new exception object and then throws this exception.

 This causes the execution to stop, because once an exception

has been thrown, it must be caught by an exception handler and
dealt with immediately.

 If no exception handlers are defined, the exception is caught by

the default handler provided by the Java run-time system.

 The default handler displays a string describing the exception,

prints a Stack trace from the point at which the exception
occurred, and terminates the program.
  The stack trace will always show the sequence of method
invocations that led up to the error.

public class Excep2

{
static void find()
{
int d = 0;
int a = 10 / d;
}
public static void main(String args[])
{
find();
}
}

The resulting stack trace from the default exception handler shows
how the entire call stack is displayed:

 The call stack is quite useful for debugging, because it pinpoints

the precise sequence of steps that led to the error.
Scanned by CamScanner
Scanned by CamScanner
Scanned by CamScanner
Scanned by CamScanner
Scanned by CamScanner
Scanned by CamScanner
Scanned by CamScanner
Scanned by CamScanner
Scanned by CamScanner
Scanned by CamScanner
Scanned by CamScanner
Scanned by CamScanner
Scanned by CamScanner
Scanned by CamScanner
Scanned by CamScanner
Scanned by CamScanner
Scanned by CamScanner
Scanned by CamScanner
Scanned by CamScanner
Scanned by CamScanner
Scanned by CamScanner
Scanned by CamScanner
Scanned by CamScanner
Scanned by CamScanner
Scanned by CamScanner
Scanned by CamScanner
Scanned by CamScanner
Scanned by CamScanner
Scanned by CamScanner
Scanned by CamScanner
Scanned by CamScanner
Scanned by CamScanner
Scanned by CamScanner
//Without Exception Handling
public class ExcepDemo1
{
public static void main(String args[])
{
int y=50;
int x=y/0;//may throw exception
System.out.println("rest of the code...");
System.out.println("Welcome to Exception Handling");
}
}

//With Exception Handling

public class ExcepDemo2

{
public static void main(String args[])
{
try
{
int y=50;
int x=y/0;//may throw exception
System.out.println("Hi hello");
}
catch (ArithmeticException e)
{
System.out.println(e); //exception object description
System.out.println("Division Error - Should not be zero in denominator");
}

System.out.println("rest of the code...");

System.out.println("Welcome to Exception Handling");
}
}

//Uncaught Exception - StackTrace

public class ExcepDemo4
{
public static void method()
{
int d=0;
int a = 10/d;
}
public static void main(String[] args)
 {
System.out.println("Hello World!");
method();
}
}

//Program to use try-catch keywords

class ExcepDemo5
{
public static void main(String args[])
{
int d, a;
try { // monitor a block of code.
d = 0;
a = 42 / d;
System.out.println("This will not be printed.");
}
catch (ArithmeticException e)
{
// catch divide-by-zero error
System.out.println("Division by zero.");
System.out.println("Exception is " +e); //displaying exception type
d = 20; //set d to other than zero
}

System.out.println("After the cathch statement ");

System.out.println("d value is " +d);
}
}

//multiple catch blocks

import java.util.*;
public class ExcepDemo6
{
public static void main(String args[])
{
Scanner sc = new Scanner(System.in);
System.out.println("Enter the no of subjects");
int n = sc.nextInt();
System.out.println("The no of Subjects is " +n);
int m[] = new int[n];
double sum=0;
System.out.println("Enter the marks");
 for(int i=0;i<n;i++)
m[i] = sc.nextInt();
for(int i =0;i<n ; i++)
sum=sum+m[i];

try
{ //int y = 25/0;
double avg = sum/n;
System.out.println("The average of the student is "+avg);
m[10] =25;
}

catch(ArrayIndexOutOfBoundsException e)
{
System.out.println("Accessing out of array");
System.out.println("Exception is " +e);
}
catch (ArithmeticException e)
{
System.out.println("No of Subjects must not be Zero");
System.out.println(e);
}

System.out.println("after the catch block");

}
}

// Demonstrate multiple catch statements.

class ExcepDemo7
{
public static void main(String args[])
{
try {
int a = args.length;
System.out.println("a = " + a);
int b = 42 / a;
int c[] = { 1 };
c[42] = 99;
}
catch(ArithmeticException e)
{
System.out.println("Divide by 0: " + e);
}
catch(ArrayIndexOutOfBoundsException e)
{
System.out.println("Array index oob: " + e);
}
System.out.println("After try/catch blocks.");
}
}

// An example of nested try statements.

public class ExcepDemo8
{
public static void main(String args[])
{
try {
int a = args.length;
int b = 42 / a;
System.out.println("a = " + a);
try {
if(a==1) a = a/(a-a); // division by zero
if(a==2)
{
int c[] = { 1,2,3 };
c[42] = 99;
// generate an out-of-bounds exception
}
}
catch(ArrayIndexOutOfBoundsException e)
{
System.out.println("Array index out-of-bounds: " + e);
}

} //outer try

catch(ArithmeticException e)
{
System.out.println("Divide by 0: " + e+ "outer");
}
}
}

//java ExcepDemo8 -> Ar.Excp

//java ExcepDemo8 9 -> Arth. Excp
//java ExcepDemo8 12 13 -> array excp.
// Demonstrate throw.
class ExcepDemo10
{
static void perform()
{
try {
// String str=null;
// System.out.println(str.length());
throw new NullPointerException("demo");
}
catch(NullPointerException e)
{
System.out.println("Caught inside perform."+e );
// System.out.println(e);
throw e; // rethrow the exception
}

public static void main(String args[])

{
try {

perform();
}
catch(NullPointerException e)
{
System.out.println("Recaught: " + e+ "main");
}

// trows clause demo

class ThrowsDemo
{
static void method() throws IllegalAccessException
{
System.out.println("Inside throwOne.");
throw new IllegalAccessException("demo");
}
 public static void main(String args[])
{
try {
method();
}
catch (IllegalAccessException e)
{
System.out.println("Caught " + e);
System.out.println("Exception caught in main");
}
}
}

//finally demonstration
public class FinallyDemo
{
public static void main(String args[])
{
try{
perform();
}
catch (ArithmeticException ae)
{
System.out.println("Exception caught in main");
System.out.println(ae);
}
finally
{
System.out.println("Finally executed in main");
}
}
public static void perform()
{
try{

int x= 25;
int d = x/0;
}
catch(ArrayIndexOutOfBoundsException ae)
{
System.out.println(ae);
}
 finally
{
System.out.println("Finally executed in method");
}
}
}

//Userdefined Exceptions
class InvalidAgeException extends Exception
{
InvalidAgeException(String s)
{
super(s);
}

public String toString()

{
return "Age Exception";
}
}

class UserExcepDemo
{
static void validate(int age)throws InvalidAgeException
{
if(age<18)
throw new InvalidAgeException(" not valid ");
else
System.out.println(" welcome to vote " +age);
}
public static void main(String args[])
{
try{
validate(23);
validate(17);
}
catch(InvalidAgeException m)
{
System.out.println("Exception occured: ");
System.out.println( m); // Description of Message
}
System.out.println("rest of the code...");
}
}
 static key word in Java
 The keyword static is used in java for a variable, a block or a method.
 The static keyword belongs to a class but not to an object.
1. Java static variables.
 Static keyword is used to define a class member that will be used
independently of any object of that class.
 A variable declared as static, then it is called static variable.
 Instance variables declared as static are global variables.
 When an object of such class is created no copy of the static variable
will exist. All instances of class share same variables.
 A static variable can be used to refer to common property of all
objects.
 Eg: Company Name, College Name etc.
 The static variables gets memory only once in a class area at the
time of class is loading in to memory.
 Static variables make the program memory efficient. i.e. it saves
memory.
 A static variable can be accessed using class name with out
instantiating it.

//static instance variables

class Student
{
int rollno;
String name;
static String college ="VCE";
static int count=0;
 Student(int r,String n)
{
rollno = r;
name = n;
count++;
}
void display ()
{
System.out.println(rollno+" "+name+" "+college);
System.out.println("count "+count);
}
}
public class StaticDemo1
{
public static void main(String args[])
{
Student s1 = new Student(501,"Karan");
s1.display();
Student s2 = new Student(545,"Aryan");
s2.display();
Student s3 = new Student(546,"Rajan");
s3.display();
System.out.println("The number of students " +Student.count);
}
}
2. Java static block
 A block of code in a class, used to initialize the static data member.
 The static block is executed before main method at the time of class is
loading.
 A class can have any number of static blocks , executes them in the
order they defined.
 Can access only static data.

//Example-1 for static block

public class StatDemo

{

int a;
static int b;
static {
// a=10; //CTE
b=0;
b=b+12;
System.out.println("Static block 1 - " +b);
}

static {

b=b-5;
System.out.println("Static block 2 - " +b);
}

public static void main(String[] args)

{
System.out.println("Hello World!- MainMethod started");
}
}
//Example-2 for static block

public class StaticDemo

{
static int x ;
static {
System.out.println("First Static Block");
x =10;
System.out.println("x is " +x);
}

static {
System.out.println("Second Static Block ");
x = x+20;
System.out.println("x is "+x);
}

public static void main(String[] args)

{
System.out.println("Hello World!- Main Program Starts here");
}
}

3. Java static block

o If we apply static keyword with any method , it is static method.
o The restrictions of static on methods declared is
 They can only directly call other static methods.
 They can only directly access static data.
 They cannot refer to with “this” or “super” keys in any way.
Because the methods belongs to a class but not to objects.
o A static method belongs to a class rather than object.
o A static method can be invoked without the need for creating an
instance of a class. (object)
o Cannot access non static data variables, data or methods directly.
o A static method is used to initialize or modify the static data.
 Why Java main method is static?

Java main method is static because

i) An object is not required to call static method.

ii) If it is non static method, JVM creates object first then call main( ) this
leads to problem of extra memory allocation.

//static method example -1

class Test
{
static int cube(int x)
{
return x*x*x;
}
static void display()
{

int x ;

x = cube(6);

System.out.println(x);
}

public class StaticDemo2

{
public static void main(String args[])
{
int result=Test.cube(5); //Directly using class name
System.out.println(result);
Test t1 = new Test();
t1.display();
}
}
//static method example -2

public class StaticDemo3

{
int a=40;//non static
static int b=20;
public void show()
{
System.out.println("Non static method");
}
public static void display()
{
b = b+5;
System.out.println("Static Method");
System.out.println(b);
a=a-5; //CTE
}

public static void main(String args[])

{
a=a+5; //CTE
System.out.println(a);
b=b+45;
System.out.println(b);
display();
show(); // CTE
}
}
 Session -25

After the completion of the session student will be able to

1. Understand Multi Tasking with Processes and

Threads.

Problem Solving Assignment

1. Differentiate between Process and Thread based
Multitasking.
2. List any 4 real time examples for Multi Threaded applications.
3. Draw the Thread state diagram.
Multi Tasking

 Deal with more than one task at the same time.

 Execute more than one program or task simultaneously.

Multi tasking is implemented in computer system using two ways.

1. Process Based Multi Tasking

 A process is a program under execution
 Allows the computer to perform two or more programs
concurrently.
 Called Process based Multi Tasking
 Run a Java Compiler and Text Editor at same time
 Each process has its own address space in memory.
 Process is a heavy weight processing unit
 Cost of communication between processes is high
 Switching from one process to another is complex
 Inter process communication is expensive and limited
 It is in the control of Operating System.
 It is not in the control of JAVA or JVM
 Process based multitasking requires more overhead.
 Taking control of CPU is difficult.
2. Thread Based Multi Tasking

 A Thread is the smallest unit of dispatch able code,

having its own execution path.
 A single program can perform two or more tasks
simultaneously.
 Called Thread based Multi Tasking
 Editing on a text file, checking for spelling, and printing.
 All the threads will share the common address space.
 Thread is a light weight processing unit
 Cost of communication between threads is low.
 Switching from one thread to another is simple.
 Inter thread communication is less expensive
 Threads are in the control of Java or JVM.
 Taking control of CPU is easy.
Multi Threading

 Java Provides built in support for multi threaded programming.

 A Multi threaded program contains two or more parts that can
run concurrently. Each part of such a program is called a Thread.
 Each thread defines a separate execution path.
 Multi Threading is a specialized form of multi tasking.
 A thread is a smallest unit of processing, it has separate
execution path.
 Thread are independent, if exception occurs in one thread it
does not affect other threads.
 Threads share common memory area
 One process can have multiple threads; the operating system
can have multiple processes.
 At a time only one thread is executed.
 At least one process required for each thread.
 A main program is single thread of execution

Advantages of MultiThreading
 Allows to write very efficient program that makes
maximum use of CPU.(Idle time can be kept minimum).
 Eg: During I/O operation , CPU switch to another thread.
 Threads are independent
 Throughput – Amount of work done in unit time increase.

Applications of Java MultiThreading

 Animations
 Gaming
 Text Editors etc
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.
New -> The thread is in new state when the instance of thread
class is created but before the invocation of start() method.
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.
Running-> The thread is in running state when the thread scheduler
selects a thread for execution.
Non-Runnable -> this is the state when the thread is still alive but is
not eligible currently to run. (Blocked)
Terminated -> A thread is in terminated or dead state when its run()
method exits.

Thread class
 Java provides Thread class to achieve thread programming.
 Thread class provides constructors and methods to create and
perform operations on a thread.
 Thread class extends Object class and implements Runnable
interface.
 Session -26
After the completion of the session student will be able to
 Create Threads using Thread class and Runnable
Interface

Problem Solving Assignment

1. Create three Threads to display the following output by
Implementing Thread class.
MultiThreading Improves Performance.

2. Create three Threads to display the following output by

extending Thread class.
MultiThreading Improves Performance.
Creating Threads
In Java a Thread is created by using two methods

1. Implementing Runnable Interface

2. Extending Thread class

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:

o Thread()
o Thread(String name)
o Thread(Runnable r)
o Thread(Runnable r, String name)

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(): returns the priority of the thread.
 4. public int setPriority(int priority): Used to set or change the
priority of the thread.

5. public String getName(): returns the name of the thread.

6. public void setName(String name): Used to set or change the
name of the thread.

7. public static Thread currentThread(): returns the reference of

currently executing thread.
8. public int getId(): returns the id of the thread.
9. Public static void sleep(long miliseconds): Causes the
currently executing thread to suspend (temporarily cease
execution) for the specified number of milliseconds.
public static void sleep(long miliseconds)

public static void sleep(long milliseconds, int nanosecs)

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

11. public void join(long miliseconds): waits for a thread to
die or terminate for the specified miliseconds.
12. public boolean isAlive(): to check the thread is still
running. Returns true if the thread is still running.
13. public void yield(): causes the currently executing thread
object to temporarily pause and allow other threads to
execute.
14. public void suspend(): is used to suspend the thread
(depricated).
15. public void resume(): is used to resume the suspended
thread (depricated).
16 . public void stop(): is used to stop the thread (depricated).
17 . public Thread.State getState(): returns the state of the
thread.

***The Thread class methods throws InterruptedException

 Main thread
import java.lang.*;
public class MainThread
{
public static void main(String args[])
{

Thread t = Thread.currentThread();
System.out.println("The current thread is "+t);
// [Thread Name , Priority ,ThreadGroupName]
System.out.println("The name of Thread is "+ t.getName());
t.setName("Demo Thread");
System.out.println("The name of Thread is "+ t.getName());
System.out.println("The priority of Thread is "+ t.getPriority());
try{
for(int i=1; i<=5;i++)
{
System.out.println(i);
Thread.sleep(1000);
}
}
catch(InterruptedException e)
{
System.out.println(e);
}

}
}

 When a Java program executes, the first thread starts is main thread.
 The Main thread is important for
o It is the thread from which other child threads re created.
o It must be the last thread to finish execution, because it
performs various shutdown actions.
 The main thread is created automatically when a program started.
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.

class MyThread extends Thread

{
public MyThread(String name)
{
super(name);
}
public void run()
{
System.out.println("MultiThreading");
System.out.println("Child Thread -> " + Thread.currentThread());
}
}

public class TheadDemo1 {

public static void main(String[] args) {

System.out.println("Main Thread");
System.out.println(Thread.currentThread());
MyThread t1 = new MyThread("One");
t1.start();
System.out.println("The child Thread -> "+t1);

}
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.

class DemoThread implements Runnable

{
Thread t;
public DemoThread()
{
t= new Thread(this , "One");
System.out.println(t);
t.start();
}
public void run()
{
System.out.println("MultiThreading");
}
}
public class ThreadDemo2 {
public static void main(String[] args) {

System.out.println(Thread.currentThread());
DemoThread d = new DemoThread();
}

}
 Session -27
After the completion of the session student will be able to
 Create Multiple Threads Using Thread class and
Runnable interface.

JAM Session:

 What are the various stages of Thread life cycle?

 Is Runnable is class or Interface?
 When a thread execution is completed?
 The first thread to execute in Java is........
 The thread execution starts from the ..........method.
 The method used to suspend the thread for a specified
period of time and resume when time completes.
 List any four Thread class methods.
 The Thread class is defined in the package.....
 The super class of Thread class is.....
Creating Mutliple Threads using Thread class
A program can spawn as many threads as needed.
//Multithreading By Extending Thread class
class NewThread extends Thread
{
NewThread(String threadname) {
super(threadname);
System.out.println("Child Thred -> " +this );
//start(); // Start the thread
}

public void run(){

try {
for(int i = 5; i > 0; i--){
System.out.println(getName ()+ ": " + i);
sleep(500);
}
}
catch (InterruptedException e){
System.out.println(getName() + "Interrupted");
}
System.out.println(getName() + " Completed");
}
}

class MultiThread1
{
public static void main(String args[])
{
Thread t = Thread.currentThread();
System.out.println("Name is --->" +t.getName());
System.out.println("Main ---> " +t);

NewThread t1 = new NewThread("One");

 //or new NewThread("ONE");
NewThread t2= new NewThread("Two");
NewThread t3 = new NewThread("Three");
t1.start();
t2.start();
t3.start();

try {
// wait for other threads to end -give long time

for(int n=1;n<=5;n++){
System.out.println("Main Thread->" +n);
Thread.sleep(500);
}
catch (InterruptedException e){
System.out.println("Main thread Interrupted");
}

System.out.println("Main thread Completed");

}
}

Creating Mutliple Threads using Runnable Interface

class NewThread implements Runnable {
Thread t;
NewThread() {
// Create a new thread
t = new Thread(this, "Child Thread");
System.out.println("Child thread: " + t);
System.out.println("The thread name is "+t.getName());
t.start(); // Start the thread
}
 // This is the entry point for the child thread.
public void run() {
try{
for(int i = 1; i <=10; i++){
System.out.println("Child Thread: ->" + t.getName() + ":" + i);
Thread.sleep(500);
}
}
catch (InterruptedException e){
System.out.println("Child interrupted.");
}
}
}
public class MultiThread2{
public static void main(String args[ ] ) {
//Thread t = Thread.currentThread();
//System.out.println("The thread name is " +t.getName());
// create a new thread-child thread
NewThread t1 = new NewThread();
NewThread t2 = new NewThread();
NewThread t3 = new NewThread();

try{
for(int i = 5; i > 0; i--) {
System.out.println("Main Thread: " + i);
Thread.sleep(1000);
}
}
catch (InterruptedException e){
System.out.println("Main thread interrupted.");
}
}
}
Creating Threads of Multiple Classes
import java.lang.*;
class FactThread extends Thread
{
FactThread(String name) {
super(name);
System.out.println("The child is " +this);
}

public void run() {

System.out.println("Enter a number");
Scanner sc = new Scanner(System.in);
int n= sc.nextInt();
int f=1;
try{
for(int i=1 ; i<=n ; i++){
f= f*i;
System.out.println("Doing --wiat");
Thread.sleep(1000);
}
}
catch(InterruptedException ie){
System.out.println("Exception");
}

System.out.println("The factorial value is " +f);

}
}
class MultiThread extends Thread
{
MultiThread(String name) {
super(name);
System.out.println("The child is " +this);
}

public void run() {

Scanner sc = new Scanner(System.in);
System.out.println("Enter a num for multiplation table");
int n = sc.nextInt();
try{
for(int i=1 ; i<=10 ; i++){
System.out.println(n + "*" + i +"=" +(n*i));
Thread.sleep(1000);
}
}
catch(InterruptedException ie) {
System.out.println("Exception");
}
}
}
public class MultiFact {
public static void main(String args[])
{
FactThread t1 = new FactThread("Fact");
MultiThread t2 = new MultiThread("Multi");

t1.start();
t2.start();

System.out.println("Main completed");
}
}
//Similarly Using Runnable Interface
The two methods of Thread class are
isAlive( ) method returns true if the thread upon which it is called is
still running, otherwise it returns false.
final boolean isAlive( )

join() method waits until the thread on which it is called

terminates. The calling thread waiting until the specified thread
joins it.
final void join( ) throws InterruptedException
This method when called from the parent (main) thread makes
parent thread wait till child thread terminates.
final void join( long msec ) throws InterruptedException
To specify a maximum amount of time that we want to wait for the
specified thread to terminate.

//Program to Demonstarte isAlive() and join()

class NewThread implements Runnable {
String name;
Thread t;
NewThread(String tname) {
name = tname;
t = new Thread(this, name);
System.out.println("New thread: " + t);
t.start();
}
public void run() {
try {
for(int i = 5; i > 0; i--) {
System.out.println(name + ": " + i);
Thread.sleep(1000);
}
}
catch (InterruptedException e) {
System.out.println(name + " interrupted.");
}
System.out.println(name + "Completed" );
}
}
public class JoinDemo
{
public static void main(String args[])
{
System.out.println("The main Thread Started");
NewThread ob1 = new NewThread("One");
NewThread ob2 = new NewThread("Two");
NewThread ob3 = new NewThread("Three");

System.out.println("Thread One is alive: "+ ob1.t.isAlive());

System.out.println("Thread Two is alive: "+ ob2.t.isAlive());
System.out.println("Thread Three is alive: "+ ob3.t.isAlive());

// wait for threads to finish

System.out.println("Waiting for child threads to finish.");

try {
ob1.t.join();
ob2.t.join();
ob3.t.join();
}
catch (InterruptedException e) {
System.out.println("Main thread Interrupted");
}

System.out.println("Thread One is alive: "+ ob1.t.isAlive());

System.out.println("Thread Two is alive: "+ ob2.t.isAlive());
System.out.println("Thread Three is alive: "+ ob3.t.isAlive());
System.out.println("Main thread Completed.");
}
}
//Program to use isAlive() and join() – extending Thread class

class NewThread extends Thread

{
String name;
NewThread(String tname)
{
name=tname;
start();
}

public void run()

{
try {
for(int i = 5; i > 0; i--) {
System.out.println(name + ": " + i);
Thread.sleep(1000);
}
}
catch (InterruptedException e) {
System.out.println(name + " interrupted.");
}
System.out.println(name + "Completed" );
}
}

class JoinDemo1
{
public static void main(String args[])
{
System.out.println("The main Thread Started");
NewThread t1 = new NewThread("One");
NewThread t2 = new NewThread("Two");
NewThread t3 = new NewThread("Three");
 System.out.println("Thread One is alive: "+ t1.isAlive());
System.out.println("Thread Two is alive: "+ t2.isAlive());
System.out.println("ThreadThree is alive: "+ t3.isAlive());

// wait for threads to finish

System.out.println("Waiting for child threads to finish.");

try {
t1.join();
t2.join();
t3.join();
}
catch (InterruptedException e) {
System.out.println("Main thread Interrupted");
}

System.out.println("Thread One is alive: "+ t1.isAlive());

System.out.println("Thread Two is alive: "+ t2.isAlive());
System.out.println("Thread Threeis alive: "+ t3.isAlive());
System.out.println("Main thread Completed.");
}
}
 Session -28
After the completion of the session student will be able to
 Assign Priority to a thread when executing multiple
threads.

Problem Solving Assignment

1. Create two threads. One thread will display even
numbers and another thread display odd numbers.
2. Create two Threads with name One and Two. Write a driver
class and assign priority two threads such that thread Two
execute first over One.
Thread Priorities
 Thread priorities are used by the thread scheduler to
decide when each thread should be allowed to run.
 A higher-priority thread get more CPU time than lower-
priority thread.
 A higher-priority thread can also pre-empt a lower-
priority one. For instance, when a lower-priority thread
is running and a higher priority thread resumes (from
sleeping or waiting on I/O; for example), it will pre-
empt the lower-priority 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.
final int getPriority( )
class NewThread extends Thread {
NewThread(String name){
super (name);
}

public void run(){

System.out.println("Hello -->"+ getName() + "->"+getPriority());
}
}

public class PriorityDemo {

public static void main(String args[]) {
// System.out.println("MainThread Priority
is:"+Thread.currentThread().getPriority());

Thread t = Thread.currentThread();
System.out.println("The main thread priority is  " +
t.getPriority());

NewThread t1 = new NewThread("One");

NewThread t2 = new NewThread("Two");
NewThread t3 = new NewThread("Three");

t1.setPriority(Thread.MIN_PRIORITY);
t2.setPriority(Thread.MAX_PRIORITY);
t3.setPriority(5);
t1.start();
t2.start();
t3.start();

}
}
 Session -29
After the completion of the session student will be able to
 Provide synchronization among threads.
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 is
o To prevent thread interferences.
o To prevent inconsistency of data.
Thread Synchronization can be of two forms
1. Mutual Exclusion
2. Inter Thread communication.

1. Mutual Exclusion
Keeps threads 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, and 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.

//synchronized Method - for Synchronization

class Table
{
synchronized void printTable(int n)
{
try{
for(int i=1;i<=10;i++) {
System.out.println(n*i);
Thread.sleep(1000);
}
}
catch(InterruptedException e) {
System.out.println(e);
}
}
}
class MyThread1 extends Thread {
Table t;
MyThread1(Table t) {
this.t=t;
}
public void run() {
t.printTable(8);
}
}

class MyThread2 extends Thread {

Table t;
MyThread2(Table t) {
this.t=t;
}
public void run() {
t.printTable(9);
}
}

public class SyncDemo1 {

public static void main(String args[]) {
Table obj = new Table();
MyThread1 t1=new MyThread1(obj);
MyThread2 t2=new MyThread2(obj);
t1.start();
t2.start();
}
}
 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.

//Thread Synchronization using - synchronized block

class Table {
void printTable(int n)
{
System.out.println("*****Hello -not synched");
//synchronized block
synchronized(this) {
for(int i=1;i<=10;i++) {
System.out.println(n*i);
try{
Thread.sleep(1000);
}
catch(InterruptedException e) {
System.out.println(e);
}
}

} //end of sync block

System.out.println("Hello -not synched");

} //end of the method
}
 class MyThread1 extends Thread{
Table t;
MyThread1(Table t){
this.t=t;
}
public void run() {
t.printTable(5);
}
}

class MyThread2 extends Thread

{
Table t;
MyThread2(Table t){
this.t=t;
}
public void run() {
t.printTable(100);
}
}

public class SyncDemo2 {

public static void main(String args[]) {
Table obj = new Table();
MyThread1 t1=new MyThread1(obj);
MyThread2 t2=new MyThread2(obj);
t1.start();
t2.start();

}
}
The form of synchronized block is

synchronized(object) {
//Statements to be synchronized
}

The form of synchronized method is

class Table
{
synchronized type methodName(arguments)
{
//method body for Synchronization
}
}
 Session -30
After the completion of the session student will be able to
 Implement communication among threads.
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.
1. wait()
2. notify()
3. 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.
1. 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.

2. 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()

3. notifyAll()- 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 ---> Inter Thread Communication.
class Buffer
{
int item;
boolean produced = false;
synchronized void produce(int x)
{
if(produced)
{
try{
wait();
}
catch(InterruptedException ie)
{
System.out.println("Exception Caught");
}
}

item =x;
System.out.println("Producer - Produced-->" +item);
produced =true;
notify();
}

synchronized int consume()

{
if(!produced)
{
try{
wait();
}
catch(InterruptedException ie)
{
System.out.println("Exception Caught " +ie);
}
 }

System.out.println("Consumer - Consumed " +item);

produced = false;
notify();
return item;
}
}

class Producer extends Thread

{

Buffer b;
Producer( Buffer b)
{
this.b = b;
start();
}

public void run()

{
b.produce(10);
b.produce(20);
b.produce(30);
b.produce(40);
b.produce(50);

}
}
class Consumer extends Thread
{
Buffer b;

Consumer(Buffer b)
{
this.b = b;
start();
}

public void run()

{
b.consume();
b.consume();
b.consume();
b.consume();
// b.consume();
// b.consume();
// b.consume();

}
}

public class PCDemo

{
public static void main(String args[])
{
Buffer b = new Buffer(); //Synchronized Object
Producer p = new Producer(b);
Consumer c = new Consumer(b);
}
}