AMITY INSTITUTE OF INFORMATION

TECHNOLOGY

BCA B,C,D 247

Semester-III
Object Oriented Programming Using
Java
Prof(Dr)Laxmi Ahuja
Learning Objectives
•Imparting java programming skill to students

•Knowledge of object oriented paradigm in

context of Java programming language

•Designing desktop applications using latest

Java based API
 Contents to be Covered
• Thread Priorities
• Thread Priorities and Thread Scheduling
• Program to show Thread Priority
• Thread Methods
• Methods to prevent Thread Execution
• yield() join() sleep()
• Thread Methods Implementation
• Synchronization
 Thread Priorities
Every Java thread has a priority that helps the operating system determine the
order in which threads are scheduled.

Java thread priorities are in the range between MIN_PRIORITY (a constant of 1)

and MAX_PRIORITY (a constant of 10). By default, every thread is given priority
NORM_PRIORITY (a constant of 5).

Threads with higher priority are more important to a program and should be
allocated processor time before lower-priority threads. However, thread priorities
cannot guarantee the order in which threads execute and are very much platform
dependent.
 Thread Priorities and Thread
Scheduling
Java thread priority
Priority in range 1-10
Time-slicing
Each thread assigned time on the processor (called a quantum)
Keeps highest priority threads running

5
 Thread Priorities & Scheduling

Ready threads

Thread.MAX_PRIORITY Priority 10 A B

Priority 9 C

Priority 8

Priority 7 D E F

Priority 6 G

Priorities Thread.NORM_PRIORITY
Priority 5 H I

and Priority 4

Scheduli
Priority 3

Priority 2 J K

ng Thread.MIN_PRIORITY Priority 1

6
 Thread Priorities
• Every thread in java has some priority
• It may be default priority generated by JVM
Or
• It may be customized priority provided explicitly by programmer

• Valid range of Thread Priority

• 0-10 or 1-10
• It is not Index the priority is always 1 to 10 but not 0-10
• MINIMUM is 1
• MAXIMUM is 10
• To represent these priorities ,Thread class contain constants i.e.
• Thread.MIN_PRIORITY==1
• Thread.NORM_PRIORITY==5
• Thread.MAX_PRIORITY==10
NOTE:
• Every thread in java has some priority It may be default priority generated by JVM or customized priority provided by programmer
• Valid range of thread priorities is 1-10 where I is MIN Priority and 10 is MAX priority
• Thread class defines the following constants to represent some standard priorities
• Thread.MIN_PRIORITY==1
• Thread.NORM_PRIORITY==5
• Thread.MAX_PRIORITY==10

Q Who is going to use thread priorities and when thread priorities will be required
• Suppose In a processor multiple threads are waiting to get the chances for processor , so In
that case thread scheduler will give chance to that thread which is having highest priority

• Thread scheduler use priorities while allocating processor

• The thread which is having highest priority will get chance first

• If we have two threads with same priority then we can't expect exact execution order it
depends on Thread scheduler ,which thread will get chance(That is taken care by Thread
scheduler what algorithm is used by scheduler so its unexpected

• Q How we get priority of a thread or set and get priority of a Thread

public final int getPriority()

public final void setPriority(int p)//int p Allows values range 1 to 10

Apart from this range we get IllegalArgumentException
t.setPriority(7);
t.setPriority(17);//ger IllegalArgumentException

Thread class define get and set() methods to set the priorities of
Thread i.e.
public final int getPriority()
public final void setPriority(int p)
 Default Priority
What is the default priority of a Thread?

The default Priority only for Main Thread is 5

For all remaining Threads default priority will be inherited from parent to
child
i.e. whatever priority parent has ,same priority will be there for the child
Thread
If Parent Priority is 10 automatically child priority will be 10

class thread1 extends Thread

{
public static void main(String args[])
{
 Program to show Thread Priority
class thread1 extends Thread
{
public static void main(String args[])
{
System.out.println(Thread.currentThread().getPriority());
//Thread.CurrentThread().setPriority(15);//Illegal arguments
Thread.currentThread().setPriority(7);
thread1 th=new thread1();//child thread but parent of thread1 is main thread
System.out.println(th.getPriority());//main thread priority is 7 which gets inherited to child
}
}
 Program
class thread1 extends Thread
to show priorities
{
public void run()
{
for(int i=0;i<10;i++)
{
System.out.println("child Thread");
}}
}
class thread2
{
public static void main(String args[])
{
thread1 th=new thread1();
th.setPriority(10);//output will be main thread then child thread
th.start();
for(int i=0;i<10;i++)
{
System.out.println("Main Thread");
}}
class thread1 extends Thread
{
public void run()
{
for(int i=0;i<10;i++)
{
System.out.println("child Thread");
}}
}
class thread2
{
public static void main(String args[])
{
thread1 th=new thread1();
//th.setPriority(10);//output will be child thread then main thread
th.start();
for(int i=0;i<10;i++)
{
System.out.println("Main Thread");
}}
}
Some platforms won't provide proper support for thread priorities
 Methods of Thread Class
• start()
• run() : Implicitly called by start()

• sleep(milliseconds)---Suspends the thread for given milliseconds of time and define in try and catch block and
sleep Thread.sleep(1000)
is a static method
• join(): This is also a static method
Waits the thread to complete its process and used in multithreading and used with try and catch
clause
• getId() : used to get the ID of a thread
• getName() : Returens name of a thread and name of a thread starts with 0
• setName(String) –Thread name will be replaced with given string
• getPriority(): Priority ranges from 1 to 10 and by default priority of every thread is 5

• setPriority(integer): used to change the priority in between 1 to 10 and by default its 5

• isAlive() :used to give the status of thread in Boolean

• TRUE---If its in still running
• FALSE –if thread completes its execution
 Preventing Thread from Execution
Three ways to stop the thread execution temporarily

• yield()
• Join()
• Sleep()

We can prevent a thread execution by using these above

methods
 yield()
yield() : Thread which require more execution time that should be pause for some time
and give time to other threads
• Any thread which takes more execution time needs Yields approach to pause the
current thread for some time and give chance to other threads which require less time
• Whenever Thread. Yield() method is there ,current execution thread will pause its
execution to give the chance for remaining waiting threads which have low priority

• If any thread executes unlimited then immediately it will pass execution to give chance
to remaining waiting threads of same priority and if no waiting thread, then the same
thread will continue its execution

• If all waiting threads having low priority, then same thread can continue its execution

• Suppose IF multiple waiting threads are there t1,t2,t3,t4 with same priority then which
thread will get the chance,that will be taken care by JVM thread scheduler not by
programmer
• Suppose currently tx thread executing with priority 7 then t1,t2,t3,t4 are all in the waiting stage with the priority 7

• Now this thread called Thread.yield () then this thread tx ,leave the processor to give the chance to remaining
thread of same priority

• When processor allocated to the t1 immediately tx will also come to waiting stage
• It depends on the thread scheduler when tx will get the chance again Programmer cannot expect result
the thread which is yielded, when it will get the chance once again it depends on thread scheduler and we cant
expect exactly depends on scheduler.

Prototype of yield method

• Public static native (methods which are implemented in non java) void yield()
• public static native void yield() //complete prototype of yield()

• Yield() stage is from running to runnable

• Some platforms won't provide proper support for yield () method

• Purpose of yield() method causes to pause current executing thread to give the chance of remaining
• Waiting threads same priority
class thread1 extends Thread
{
public void run()
{
for(int i=0;i<10;i++)
{
System.out.println("Child Thread");
Thread. Yield();
}//this line executed by child method child thread always live in the processor, so our other thread is main()
}}
class thread2
{
public static void main(String args[])
{
thread1 th=new thread1();
th.start();//After this thread we have two threads main and child but //child thread invoking always yield ()
//and give the chance to remaining thread //and here remaining thread is main() and main() thread gets
more no //of times
for(int i=0;i<10;i++)
{
System.out.println("Main Thread");}}} //save it as thread2.java
 Join()
• If a thread wants to wait until completion of certain thread then we use join()
• If Thread1 wants to wait until thread2 completes execution
• If t1 is there and t2 is there and both are executing and t1 wants to wait until completing t2 then t1 has
to call join() method.
• If a thread wants to wait until completing some other thread then we should go for join() method
• For Example if a thread t1 wants to wait until completing t2 then t1 has to call t2.join()
• If t1 executes t2.join() then immediately t1 will be entered into waiting state until t2 completes and once
a t2 completes then t1 can continue its execution

• If three threads are there

1. Venue fixing thread(Thread1)
2. Wedding card printing (Thread2) has to wait until complete venue fixing thread
3. Wedding card distribution (Thread3)has to wait until card printing is completed

• Wedding card printing Thread(t2) has to wait until venue fixing thread (t1) completion hence t2 has to
call t1.join()
• Wedding card distribution Thread(t3)has to call until Wedding card printing thread(t2)completion hence
t3 has to call t2.join()method
Prototype of join() method
public final void join()
public final void join(long millisecond)//I will wait till this much millisecond

public final void join(long millisecond int nanoseconds)// I will wait till this much
milliseconds and this much nanoseconds

Every join () throws Interrupted Exception which is checked Exception hence

compulsory we should handle this exception either by using try catch or by
throws keyword otherwise we will get compile time error

In the life cycle of Thread

If thread is in running stage and in the middle it calls join() method it move to
the waiting state and from waiting state when thread will come out
 Program using join() method

class thread1 extends Thread

{
public void run()
{
for(int i=0;i<10;i++)
{
System.out.println("child Thread");
try
{
Thread.sleep(2000);
}
catch(InterruptedException e)
{}
}
}}
class thread2
{
public static void main(String args[]) throws InterruptedException
{
thread1 th=new thread1();
th.start();
//th.join();//Main thread calls join () on child thread object hence Main thread will
wait //until completing child thread ,In this case output will be child thread 10 times
followed //by Main thread 10 Times and if put this in comment //both main and child
thread //execute simultaneously and we cannot expect exact //output
for(int i=0;i<10;i++)
{
System.out.println("Main Thread");
}
}
}
 Methods of Threads Implementation—using
start and run() methods
class thread1 extends Thread
{
public void run()
{
for(int i=0;i<5;i++)
{
System.out.println(i);
}
}}
class thread2
{
public static void main(String args[])
{
thread1 th=new thread1();
th.start();
}
 getId(), getName() methods and
setName()
class thread1 extends Thread
{
public void run()
{
for(int i=0;i<5;i++)
{
System.out.println(i);
}
}}
class thread2
{
public static void main(String args[])
{
thread1 th=new thread1();
System.out.println("ID="+th.getId());
System.out.println("Name of thread is "+th.getName());
th.setName("New Thread");/ /we can set our own name (Any name can be set)
System.out.println("Name of thread after new Name" +th.getName());
th.start();
 Sleep() –It’s a static method and can be called by using met
name or class name
class thread1 extends Thread
{
public void run()
{
for(int i=0;i<5;i++)
{
try
{
Thread.sleep(1000);
}
catch(Exception e)
{
System.out.println(i);
}
}}
 Cont…

public static void main(String args[])

{
thread1 th=new thread1();
System.out.println("ID="+th.getId());
System.out.println("Name of thread is"+th.getName());
th.setName("Amity");
System.out.println("Name of thread after new Name" +th.getName());
th.start();
}
}
 getPriority()
class thread1 extends Thread
{
public void run()
{
for(int i=0;i<5;i++)
{
try
{
Thread.sleep(1000);//Thread will be waiting for 1000 milliseconds
}
catch(Exception e)
{}
System.out.println(i);
}
}}
class thread2
{
public static void main(String args[])
{
thread1 th=new thread1();
System.out.println("Priority of Thread is:" +th.getPriority());
th.setPriority(1);///change the Priority
System.out.println("Priority of Thread after changing " +th.getPriority());
th.start();
}
}
 Program without using Join()—both
threads run simultaneously
class thread1 extends Thread
{
public void run()
{
Thread t=currentThread();//whenever th.start executed that particular object will be assigned to t and that will be
//executed and whenever th1 will be executed then current thread will give the object of the current //thread and
that //will be assigned to t
for(int i=0;i<5;i++)
{
try
{
Thread.sleep(1000);//Thread will be waiting for 1000 milliseconds
}
catch(Exception e)
{}
System.out.println(i);
}
}}
class thread2
{
public static void main(String args[])
{
thread1 th=new thread1();//create two objects of the same
class
thread1 th1=new thread1();
th.start();
th1.start();//two threads will be running here
}
}
 Using Join()

class thread1 extends Thread

{
public void run()
{
Thread t=currentThread();
for(int i=0;i<5;i++)
{
try
{
Thread.sleep(1000);//Thread will be waiting for 1000
milliseconds
}
catch(Exception e)
{}
System.out.println(i);
}
}}
 Cont…

class thread2
{
public static void main(String args[])
{
thread1 th=new thread1();//create two objects of the same class
thread1 th1=new thread1();
th.start();
try
{
th.join();//In the absence of join two threads were running simultaneously but using join we are joining
the //threads so th1 will be waiting until the one thread th completes execution
}
catch(Exception e)
{
}
th1.start();//two threads will be running here
}
}
 Cont…

class thread1 extends Thread

{
public void run()
{
Thread t=currentThread();
for(int i=0;i<5;i++)
{
try
{
Thread.sleep(1000);//Thread will be waiting for 1000
milliseconds
}
catch(Exception e)
{}
System.out.println(i);
}
}}
 Extending Thread
class newthread extends Thread
{
newthread()
{
super(“Demo Thread”);
System.out.println(“child thread” +this);
Start();
}
public void run()
{
try
{
for(int i=5;i>0;i--)
{
System.out.println(“Child Thread” +i);
Thread.sleep(500);
}
}
catch(InterruptedException e)
{
System.out.println(“child Interrupted”);
}
System.out.println(“Exiting child thread”);
}
public static void main(String args[])
{
new NewThread();
{
try
{
for(int i=5;i<5;i>0;i--)
{
System.out.println(“Main Threead” +i);
Thread.sleep(1000);

}
}
catch(InterruptedException e)
{
System.out.println(“Main Thread Interrupted”);
}
System.out.println(“Main Thread Exiting”);}}
child Thread:Thread[Demo Thread,5,main]
Main thread : 5
child thread :4
child thread :4

Main thread : 4
child thread :3
child thread :2

Main thread : 3
child thread :3
child thread :1

Main thread : 2
child thread :2
child thread :1

Main thread exiting

 Creating thread using thread
class A extends Thread
{
class
public void run()
{

for(int i=1;i<=5;i++)
}
System.out.println(“From thread A :i=“i);
}
System.out.println(“Exit from A”);
}
}
class B extends Thread
{
public void run()
{
for(int j=1;j<=5;j++)
{
System.out.println(“\t from thread B:j=“+j);
}
}
class C extends Thread
{
public void run()
{
for(int k=1;k<5;k++)
{
System.out.println(“From thread C:k=“+k);
}
System.out.println(“Exit from C”);
}
public static void main(String args[])
{
new A().start();
new B().start();
new C().start();
}
}
 Thread Methods
Methods with Description

public void start()

Starts the thread in a separate path of execution, then invokes the run() method on
this Thread object.

public void run()

If this Thread object was instantiated using a separate Runnable target, the run()
method is invoked on that Runnable object.

public final void setName(String name)

Changes the name of the Thread object. There is also a getName() method for retrieving the name.
public final void setPriority(int priority)

Sets the priority of this Thread object. The possible values are between 1 and 10.

public final void setDaemon(boolean on)

A parameter of true denotes this Thread as a daemon thread.

public final void join(long millisec)

The current thread invokes this method on a second thread, causing the current thread
to block until the second thread terminates or the specified number
of milliseconds
passes.

public void interrupt()

Interrupts this thread, causing it to continue execution if it was
blocked for any reason.

public final boolean isAlive()

Returns true if the thread is alive, which is any time after the thread
has been started
but before it runs to completion
THANK YOU