Java threads

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

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

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

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

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

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

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

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

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

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

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

Java threads

Recommended

More Related Content

What's hot (20)

Similar to Java threads (20)

More from Dr. Jasmine Beulah Gnanadurai (20)

Recently uploaded (20)

Java threads