Java Threads, Life Cycle of Threads

1. Java Threads
Dr. G.Jasmine Beulah
Assistant Professor, Dept.Computer Science,
Kristu Jayanti College, Bengaluru

2. 2
Introduction
• Performing operations concurrently (in parallel)
• We can walk, talk, breathe, see, hear, smell... all at the same time
• Computers can do this as well - download a file, print a file,
receive email, run the clock, more or less in parallel….
• How are these tasks typically accomplished?
• Operating systems support processes
• What’s the difference between a process and a thread?
• Processes have their own memory space, threads share memory
• Hence processes are “heavyweight” while threads are “lightweight”
• Most programming languages do not allow concurrency
• Usually limited to operating system "primitives" available to
systems programmers
• Java supports concurrency as part of language and libraries

3. 3
What and why
• Threads of execution
• Each thread is a portion of a program that can execute concurrently with
other threads (multithreading)
• C and C++ are single-threaded
• Gives Java powerful capabilities not found in C and C++
• Example: downloading a video clip
• Instead of having to download the entire clip then play it:
• Download a portion, play that portion, download the next portion, play that portion...
(streaming)

4. Threads Concept
Multiple
threads on
multiple
CPUs
Multiple
threads
sharing a
single CPU
Thread 3
Thread 2
Thread 1
Thread 3
Thread 2
Thread 1
4

5. 5
Creating Threads – Using Thread class
1. Declare the class as extending the Thread class.
2. Implement the run() method – responsible for executing the
sequence of code.
3. Create a thread object and call the start() method to initiate the
thread execution.

6. 6
Creating Threads – Using Thread class
1. Declaring the class
class MyThread extends Thread
{
…..}
2. Implementing the run() method
public void run()
{ ……}
3. Starting New Thread
MyThread a1= new MyThread();
a1.start(); //invokes run() method

7. //Example to create threads
class A extends Thread
{
public void run()
{
for(int i=0;i<5;i++)
{
System.out.println("From ThreadA: i= " +i);
}
System.out.println("Exit from A");
}
}
7

8. class B extends Thread
{
public void run()
{
for(int j=0;j<5;j++)
{
System.out.println("From ThreadB: j= " +j);
}
System.out.println("Exit from B");
}
}
8

9. class C extends Thread
{
public void run()
{
for(int k=0;k<5;k++)
{
System.out.println("From ThreadC: k= " +k);
}
System.out.println("Exit from K");
}
}
9

10. class MyThread
{
public static void main(String args[])
{
A a1=new A();
a1.start();
B b1=new B();
b1.start();
C c1=new C();
c1.start();
}}
10

11. Creating Threads-Using runnable interface
1. Declare the class as implementing the Runnable interface
2. Implement the run() method.
3. Create a thread by defining an object
4. Call the thread’s start() method to run the thread.
11

12. Creating Threads-Using runnable interface
class X implements Runnable
{
public void run()
{
for(int i=1;i<=10;i++)
{
System.out.println("From Thread X: = " +i);
}
System.out.println("End of ThreadX");
}
}
12

13. class Test
{
public static void main(String args[])
{
X a1=new X();
Thread threadX=new Thread(X);
threadX.start();
System.out.println("End of Thread");
}
}
13

14. Life cycle of a Thread
14

15. 15
Thread States: Life Cycle of a Thread
• Born state
• Thread just created
• When start called, enters ready state
• Ready state (runnable state)
• Highest-priority ready thread enters running state
• Running state
• System assigns processor to thread (thread begins executing)
• When run completes or terminates, enters dead state
• Dead state
• Thread marked to be removed by system
• Entered when run terminates or throws uncaught exception

16. 16
Thread States
• Blocked state
• Entered from running state
• Blocked thread cannot use processor, even if available
• Common reason for blocked state - waiting on I/O request
• Sleeping state
• Entered when sleep method called
• Cannot use processor
• Enters ready state after sleep time expires
• Waiting state
• Entered when wait called in an object thread is accessing
• One waiting thread becomes ready when object calls notify
• notifyAll - all waiting threads become ready

17. 17
Thread Methods
• static void sleep( long milliseconds )
• Thread sleeps (does not contend for processor) for number of milliseconds
• Why might we want a program to invoke sleep?
• Can give lower priority threads a chance to run
• void interrupt() - interrupts a thread
• boolean isInterrupted()
• Determines if a thread is interrupted
• boolean isAlive()
• Returns true if start called and thread not dead (run has not completed)
• getPriority() - returns this thread's priority
• setPriority() – sets this threads priority
• Etc.

18. 18
Thread Priorities and Scheduling
• All Java applets / applications are multithreaded
• Threads have priority from 1 to 10
• Thread.MIN_PRIORITY - 1
• Thread.NORM_PRIORITY - 5 (default)
• Thread.MAX_PRIORITY - 10
• New threads inherit priority of thread that created it
• Timeslicing
• Each thread gets a quantum of processor time to execute
• After time is up, processor given to next thread of equal priority
• Without timeslicing, each thread of equal priority runs to completion

19. 19
Thread Priorities and Scheduling
• Java scheduler
• Keeps highest-priority thread running at all times
• If timeslicing available, ensure equal priority threads execute in round-robin
fashion
• New high priority threads could postpone execution of lower priority threads
• Indefinite postponement (starvation)
• Priority methods
• setPriority( int priorityNumber )
• getPriority
• yield - thread yields processor to threads of equal priority