Multithreaded Programming

using Java Threads

Web/Internet Applications:
Serving Many Users Simultaneously
PC client

Internet
Server
Local Area Network

PD
A
2

Modern Applications need Threads (ex1):

Editing and Printing documents in background.
Printing Thread

Editing Thread

Multithreading is a conceptual programming paradigm

where a program (process) is divided into two or more
subprograms (processes), which can be implemented at
the same time in parallel.

A thread is a program that has a single flow of control

It has a beginning, a body, and an end, and executes

commands sequentially.

A unique property of java is its support for multi threading

Java enables us to use multiple flows of control in
developing programs
Each flow of control may be thought of as a separate tiny
program (or module) known as thread that runs in parallel
to others
A program that contains multiple flows of control is
known as Multithreaded program

A single threaded program

class ABC
{
.
public void main(..)
{

..
}

beginning

Single-threaded body
of execution

end

A Multithreaded Program
Main Thread

start

Thread A

start

Thread B

start

Thread C

Threads may switch or exchange data/results

8

Contd..

Java program with 4 threads, one main and three others

The main thread is actually the main method module,
which is designed to create and start the other three
threads, namely A,B and C
The threads A, B and C run concurrently and share the
resources concurrently
The ability of a language to support multithreads is
referred to as concurrency

Single and Multithreaded Processes

threads are light-weight processes within a process
Single-threaded Process

Multiple threaded Process

Threads of
Execution

Multiple instruction stream

Single instruction stream Common
Address Space
10

Benefits

It enables programmers to do multiple things at one

time
We can divide a long program (containing operations
that are conceptually concurrent) into threads and
execute them in parallel

11

Life cycle of a thread

Newborn state
Runnable state
Running state
Blocked state
Dead state

Life Cycle of Thread

Newborn
start

Active
Thread

stop

Runnable

Running

stop

Killed
Thread

yield
Suspend

resume
notify

Sleep

Dead

stop

wait
Idle Thread
(Not
Runnable)

Blocked

13

Newborn state

When we create a thread object, the thread is born and

is said to be in Newborn state
The thread is not yet scheduled for running
At this state, we can do only one of the following things
with it:
Schedule it for running using start() method
Kill it using stop() method

Newborn

start

Runnable state

stop

Dead State

Runnable state

Means that the thread is ready for execution and is

waiting for the availability of the processor
The process of assigning time to threads is known as
TIME-SLICING
YIELD

Running
Thread

Runnable threads

Relinquishing control using yield() method

Running State

This means that the processor has given its

time to the thread for its execution

A running thread may relinquish its control in

one of following situations:

Suspend

resume

Running

Runnable

suspended

Sleep(t)

After t

Running

Runnable

sleeping

wait

notify

Running

Runnable

waiting

Blocked state

A thread is said to be blocked when it is

prevented from entering into runnable
state and subsequently the running state.

Blocking a thread

A thread can be temporarily suspended or blocked from

entering into the runnable and subsequently running
state by using either of the methods:

sleep()
suspend()
wait()

// blocked for a specified time

// blocked until further orders

// blocked until certain condition occurs

These methods cause the thread to go into the blocked state (or not
runnable) state.
Sleep() : when specified time is elapsed
Suspend(): resume() method is invoked
Wait(): notify() method is invoked

Stopping a thread

Whenever we want to stop a thread from running

further, we may do by calling
aThread.stop();

This moves the thread to dead state.

The stop method may be used when the premature
death of a thread is desired

Creating threads

Threads are implemented in the form of objects

that contain a method called run()

A typical run() would appear as follows:

public void run()

{
..
.. (statements for implementing thread)
}
23

A new thread can be created in 2 ways:

By creating a thread class

By converting a class to a thread: Define a class

: Define a class that

extends thread class and override its run() method with the code
required by the thread

that implements Runnable interface. The Runnable interfaces

has only one method., run(), that is to defined in the method
with the code to be executed by the thread

24

Threading Mechanisms...

Create a class that extends the Thread class

Create a class that implements the Runnable interface

Thread

MyThread

(objects are threads)

[a]

Runnable

Thread

MyClass

(objects with run() body)

[b]
25

1st method: Extending Thread class

Create a class by extending Thread class and

override run() method:
class MyThread extends Thread
{
public void run()
{
// thread body of execution
}
}

Create a thread:
MyThread thr1 = new MyThread();
Start Execution of threads:
thr1.start();
//invokes run() method
Create and Execute:
new MyThread().start();
26

An
example
class MyThread extends Thread
{

public void run()

{
for(int i=1;i<=5;i++)
{
System.out.println( this thread is running:i +i);
}
System.out.println(exit from A);
}

class ThreadEx1
{
public static void main (String [] args )
{
MyThread t = new MyThread();
t.start();
}
}

27

2nd method: Threads by

implementing Runnable interface

Create a class that implements the interface

Runnable and override run() method:

class MyThread implements Runnable

{
.....
public void run()
{
// thread body of execution
}
}
Creating Object:
MyThread myObject = new MyThread();
Creating Thread Object:
Thread thr1 = new Thread(myObject);
Start Execution:
thr1.start();
28

An example
class MyThread implements Runnable
{
public void run()
{
System.out.println(" this thread is running ... ");
}
}

class ThreadEx2
{
public static void main (String [] args )
{
Thread t = new Thread(new MyThread());
t.start();
}
}
29

A Program with Three Java Threads

Write a program that creates 3 threads

30

Three threads example

class A extends Thread
{
public void run()
{
for(int i=1;i<=5;i++)
{
System.out.println("\t From ThreadA: 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 ThreadB: j= "+j);
}
System.out.println("Exit from B");
}
}

31

class C extends Thread

{
public void run()
{
for ( int k=1;k<=5;k++)
{
System.out.println ("\t From ThreadC: k= "+k);
}
System.out.println ("Exit from C");
}
}
class ThreadTest
{
public static void main (String args[])
{
new A().start();
new B().start();
new C().start();
}
}
32

Run 1
Javac ThreadTest.java
java ThreadTest
From ThreadA: i= 1
From ThreadA: i= 2
From ThreadA: i= 3
From ThreadA: i= 4
From ThreadA: i= 5
Exit from A
From ThreadC: k= 1
From ThreadC: k= 2
From ThreadC: k= 3
From ThreadC: k= 4
From ThreadC: k= 5
Exit from C
From ThreadB: j= 1
From ThreadB: j= 2
From ThreadB: j= 3
From ThreadB: j= 4
From ThreadB: j= 5
Exit from B

33

Run2
[raj@mundroo] threads [1:77] java ThreadTest
From ThreadA: i= 1
From ThreadA: i= 2
From ThreadA: i= 3
From ThreadA: i= 4
From ThreadA: i= 5
From ThreadC: k= 1
From ThreadC: k= 2
From ThreadC: k= 3
From ThreadC: k= 4
From ThreadC: k= 5
Exit from C
From ThreadB: j= 1
From ThreadB: j= 2
From ThreadB: j= 3
From ThreadB: j= 4
From ThreadB: j= 5
Exit from B
Exit from A
34

Example 2
class A extends Thread
{
public void run()
{
for(int i=1;i<=5;i++)
{
if(i==1) yield();
System.out.println("\t 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);
if (j==3) stop();
}
System.out.println("Exit from B");
}
}

35

class C extends Thread

{
public void run()
{
for(int k=1;k<=5;k++)
{
System.out.println("\t From Thread C: k= +k);
if (k==1)
{
sleep(1000);
}
}
System.out.println(Exit from C);
}
}

36

class ThreadMethods
{
public static void main(String args[])
{
A threadA=new A();
B threadB=new B();
C threadC=new C();
System.out.println("Start Thread A");
threadA.start();
System.out.println("Start Thread B");
threadB.start();
System.out.println("Start Thread C");
threadC.start();

System.out.println("End of main thread");

}
}

37

Start thread A
Start thread B
Start thread C
From thread B: j=1
From thread B: j=2
From thread B: j=3
From thread A: i=1
From thread A: i=2
End of main thread
From thread C: k=1
From thread A: i=3
From thread A: i=4
From thread A: i=5
Exit from A
From thread C: k=2
From thread C: k=3
From thread C: k=4
From thread C: k=5
Exit from C

38

39

Using isAlive() and join()

Two ways exist to determine whether a thread has finished.

First, you can call isAlive( ) on the thread.

This method is defined by Thread, and its general form is:
final boolean isAlive( )
The isAlive( ) method returns true if the thread upon which it is
called is still running.
It returns false otherwise.

40

Contd..
While isAlive( ) is occasionally useful, the method
that you will more commonly use to wait for a thread
to finish is called join( ), shown here:
final void join( ) throws InterruptedException
This method waits until the thread on which it is called
terminates.
Its name comes from the concept of the calling thread waiting
until the specified thread joins it.

41

Thread Priority

In Java, each thread is assigned priority, which affects

the order in which it is scheduled for running. The
threads so far had same default priority
(NORM_PRIORITY) and they are served using FCFS
policy.
Java allows users to change priority:

ThreadName.setPriority(intNumber)

MIN_PRIORITY = 1
NORM_PRIORITY=5
MAX_PRIORITY=10

42

Thread Priority Example

class A extends Thread
{
public void run()
{
System.out.println("Thread A started");
for(int i=1;i<=4;i++)
{
System.out.println("\t From ThreadA: i= "+i);
}
System.out.println("Exit from A");
}
}
class B extends Thread
{ public void run()
{
System.out.println("Thread B started");
for(int j=1;j<=4;j++)
{
System.out.println("\t From ThreadB: j= "+j);
}
System.out.println("Exit from B");
}}

43

Thread Priority Example

class C extends Thread
{ public void run()
{ System.out.println("Thread C started");
for(int k=1;k<=4;k++)
{
System.out.println("\t From ThreadC: k= "+k);
}
System.out.println("Exit from C");
}}
class ThreadPriority
{ public static void main(String args[])
{
A threadA=new A();
B threadB=new B();
C threadC=new C();
threadC.setPriority(Thread.MAX_PRIORITY);
threadB.setPriority(threadA.getPriority()+1);
threadA.setPriority(Thread.MIN_PRIORITY);
System.out.println("Started Thread A");
threadA.start();
System.out.println("Started Thread B");
threadB.start();
System.out.println("Started Thread C");
threadC.start();
System.out.println("End of main thread"); } }
44

Start thread A
Start thread B
Start thread C
threadB started
From ThreadB: j= 1
From ThreadB: j= 2
threadC started
From ThreadC: k= 1
From ThreadC: k= 2
From ThreadC: k= 3
From ThreadC: k= 4
Exit from C
End of main thread
From ThreadB: j= 3
From ThreadB: j= 4
Exit from B
threadA started
From ThreadA: i= 1
From ThreadA: i= 2
From ThreadA: i= 2
From ThreadA: i= 2
Exit from A

Run 1

45

Accessing Shared Resources

Applications Access to Shared Resources need

to be coordinated.

Printer (two person jobs cannot be printed at the

same time)
Simultaneous operations on your bank account.
Can the following operations be done at the same
time on the same account?

Deposit()
Withdraw()
Enquire()

46

Online Bank: Serving Many Customers

and Operations
PC client

Internet Bank
Server
Local Area Network

Bank
Database

PD
A
47

class Callme
{
void call(String msg)
{
System.out.print("[" + msg);
try
{
Thread.sleep(1000);
}
catch(InterruptedException e)
{
System.out.println("Interrupted");
}
System.out.println("]");
}
}

class Caller implements Runnable

{
String msg;
Callme target;
Thread t;
public Caller(Callme targ, String s)
{
target = targ;
msg = s;
t = new Thread(this);
t.start();
}
public void run()
{
target.call(msg);
}
}

48

class Synch {
public static void main(String args[])
{
Callme target = new Callme();
Caller ob1 = new Caller(target, "Hello");
Caller ob2 = new Caller(target, "Synchronized");
Caller ob3 = new Caller(target, "World");
// wait for threads to end
try
{
ob1.t.join();
ob2.t.join();
ob3.t.join();
} catch(InterruptedException e) {
System.out.println("Interrupted");
}
}
}

49

Here is the output produced by this

program:
Hello[Synchronized[World]
]
]

50

Solution 1
class Callme {
synchronized void call(String msg) {
...
}
}
After synchronized has been added to call( ), the
output of the program is as follows:

[Hello]
[Synchronized]
[World]

51

Solution 2
put calls to the methods defined by this class inside a synchronized
block.
This is the general form of the synchronized statement:
synchronized(object) {
// statements to be synchronized
}
Here, object is a reference to the object being synchronized. A
synchronized block ensures that a call to a method that is a member
of object occurs only after the current thread has successfully
entered objects monitor.

52

class Callme
{
void call(String msg)
{
System.out.print("[" + msg);
try
{
Thread.sleep(1000);
}
catch(InterruptedException e)
{
System.out.println("Interrupted");
}
System.out.println("]");
}
}

class Caller implements Runnable

{
String msg;
Callme target;
Thread t;
public Caller(Callme targ, String s)
{
target = targ;
msg = s;
t = new Thread(this);
t.start();
}
public void run()
{
synchronized(target) {
target.call(msg); }
}
}
53

class Synch {
public static void main(String args[])
{
Callme target = new Callme();
Caller ob1 = new Caller(target, "Hello");
Caller ob2 = new Caller(target, "Synchronized");
Caller ob3 = new Caller(target, "World");
// wait for threads to end
try
{
ob1.t.join();
ob2.t.join();
ob3.t.join();
} catch(InterruptedException e) {
System.out.println("Interrupted");
}
}
}

54

Comparison

55