Multithreaded

Programming using Java

Threads

Prof. Rajkumar Buyya

Cloud Computing and Distributed Systems (CLOUDS) Laboratory
Dept. of Computer Science and Software Engineering
University of Melbourne, Australia
[Link] or
[Link]
1
 Agenda
 Introduction
 Thread Applications
 Defining Threads
 Java Threads and States

Priorities
 Accessing Shared Resources

Synchronisation
 Assignment 1:

Multi-Threaded Math Server
 Advanced Issues:

Concurrency Models: master/worker, pipeline, peer
processing

Multithreading Vs multiprocessing

2
A single threaded program

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

{
… body

.. end
}
}

3
A Multithreaded Program

Main Thread

start
start start

Thread A Thread B Thread C

Threads may switch or exchange data/results

4
 Single and Multithreaded
Processes
threads are light-weight processes within a process

Single-threaded Process Multiplethreaded

Threads of Process
Execution

Single instruction stream Common Multiple instruction stream

Address Space

5
 Multithreaded Server: For
Serving Multiple Clients
Concurrently

Client 1 Server Process

Process
Server
Threads
 Internet

Client 2
Process

6
Web/Internet Applications:
Serving Many Users
Simultaneously
PC client

Internet
Server
Local Area Network

PDA

7
Modern Applications need Threads (ex1):
Editing and Printing documents in
background.
Printing
Printing Thread
Thread

Editing
Editing
Thread
Thread

8
Multithreaded/Parallel File
Copy
reader()
reader()
{{ writer()
writer()
-- -- -- -- -- -- -- -- -- buff[0] {{
-- buff[0]
-- -- -- -- -- -- -- -- -- --
lock(buff[i]);
lock(buff[i]); lock(buff[i]);
buff[1] lock(buff[i]);
read(src,buff[i]);
read(src,buff[i]); buff[1] write(src,buff[i]);
write(src,buff[i]);
unlock(buff[i]);
unlock(buff[i]); unlock(buff[i]);
unlock(buff[i]);
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
-- }}
}}

Cooperative
Cooperative Parallel
Parallel
Synchronized
Synchronized Threads
Threads 9
 Levels of Parallelism
Code-Granularity
Code-Granularity
Code
CodeItem
Item
Sockets/ Task
Taski-l
i-l Task
Taskii Task
Taski+1
i+1 Large
Largegrain
grain
PVM/MPI (task
(tasklevel)
level)
Program
Program

func1
func1( () ) func2
func2( () ) func3
func3( () )
{{ {{ {{ Medium
Mediumgrain
grain
Threads ....
....
....
....
....
....
....
....
....
(control
(controllevel)
level)
.... .... .... Function
}} }} }} Function(thread)
(thread)

Fine
Finegrain
grain
aa( (00) )=.. aa( (11)=.. aa( (22)=.. (data
Compilers =..
bb( (00) )=..
)=..
bb( (11)=..
)=..
bb( (22)=.. (datalevel)
level)
=.. )=.. )=.. Loop
Loop(Compiler)
(Compiler)

Very
Veryfine
finegrain
grain
CPU ++ xx Load
Load (multiple
(multipleissue)
issue)
With
Withhardware
hardware
10
 What are Threads?
 A piece of code that run in concurrent
with other threads.
 Each thread is a statically ordered
sequence of instructions.
 Threads are being extensively used
express concurrency on both single and
multiprocessors machines.
 Programming a task having multiple
threads of control – Multithreading or
Multithreaded Programming.
11
 Java Threads
 Java has built in thread support for
Multithreading
 Synchronization
 Thread Scheduling
 Inter-Thread Communication:
 currentThread start setPriority
 yield run getPriority
 sleep stop suspend
 resume
 Java Garbage Collector is a low-priority
thread.
12
 Threading Mechanisms...
 Create a class that extends the Thread
class
 Create a class that implements the
Runnable interface
Thread Runnable Thread

MyThread MyClass

(objects are threads) (objects with run() body)

[a] [b]

13
 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:
[Link]();
 Create and Execute:
new MyThread().start();

14
 An example
class MyThread extends Thread {
public void run() {
[Link](" this thread is running ... ");
}
}

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

15
 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:
[Link]();

16
 An example
class MyThread implements Runnable {
public void run() {
[Link](" this thread is running ... ");
}
}

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

17
 Life Cycle of Thread
new
start()
I/O completed

ready resume()
Time expired/
notify() interrupted

sleeping blocked
waiting
dispatch
sleep()
wait() suspend()
running Block on I/O
completion

stop() dead
18
 A Program with Three Java
Threads
 Write a program that creates 3
threads

19
 Three threads example
 class A extends Thread
 {
 public void run()
 {
 for(int i=1;i<=5;i++)
 {
 [Link]("\t From ThreadA: i= "+i);
 }
 [Link]("Exit from A");
 }
 }

 class B extends Thread

 {
 public void run()
 {
 for(int j=1;j<=5;j++)
 {
 [Link]("\t From ThreadB: j= "+j);
 }
 [Link]("Exit from B");
 }
 }

20
 class C extends Thread
 {
 public void run()
 {
 for(int k=1;k<=5;k++)
 {
 [Link]("\t From ThreadC: k= "+k);
 }

 [Link]("Exit from C");

 }
 }

 class ThreadTest
 {
 public static void main(String args[])
 {
 new A().start();
 new B().start();
 new C().start();
 }
 }

21
 Run 1
 [raj@mundroo] threads [1:76] 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

22
 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

23
 Process Parallelism
 int add (int a, int b, int & result)
 // function stuff
 int sub(int a, int b, int & result) Data
 // function stuff Processor
IS1 aa
add
add
pthread
bb
pthreadt1,
t1,t2;
t2;
pthread-create(&t1,
pthread-create(&t1,add,add,a,b,
a,b,&&r1);
r1); r1
r1
Processor
pthread-create(&t2,
pthread-create(&t2,sub,sub,c,d,
c,d,&&r2);
r2); cc
pthread-par
pthread-par(2,
(2,t1,
t1,t2); IS2
t2);
sub
sub
dd
r2
r2
MISD and MIMD Processing
24
 Data Parallelism
 sort( int *array, int count) Data
 //......
Processor do
 //......
“
Sort
Sort “
pthread-t,
pthread-t,thread1,
thread1,thread2;
thread2;
““ IS dn/2
““
pthread-create(&
pthread-create(&thread1,
thread1,sort,
sort,array,
array,N/2);
N/2);
pthread-create(& Processor
pthread-create(&thread2,
thread2,sort,
sort,array,
array,N/2);
N/2); dn2/+1
pthread-par(2, thread1, thread2);
pthread-par(2, thread1, thread2);
Sort
Sort “
“
SIMD Processing dn
25
 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:

[Link](intNumber)
 MIN_PRIORITY = 1
 NORM_PRIORITY=5
 MAX_PRIORITY=10

26
 Thread Priority Example
class A extends Thread
{
public void run()
{
[Link]("Thread A started");
for(int i=1;i<=4;i++)
{
[Link]("\t From ThreadA: i= "+i);
}
[Link]("Exit from A");
}
}
class B extends Thread
{
public void run()
{
[Link]("Thread B started");
for(int j=1;j<=4;j++)
{
[Link]("\t From ThreadB: j= "+j);
}
[Link]("Exit from B");
}
}

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

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

29
Online Bank: Serving Many
Customers and Operations

PC client

Internet Bank
Server
Local Area Network

Bank
Database PDA

30
 Shared Resources
 If one thread tries to read the data and
other thread tries to update the same
data, it leads to inconsistent state.
 This can be prevented by synchronising
access to the data.
 Use “Synchronized” method:
 public synchronized void update()
 {

…
 }

31
 the driver: 3rd Threads
sharing the same object
class InternetBankingSystem {
public static void main(String [] args ) {
Account accountObject = new Account ();
Thread t1 = new Thread(new MyThread(accountObject));
Thread t2 = new Thread(new YourThread(accountObject));
Thread t3 = new Thread(new HerThread(accountObject));
[Link]();
[Link]();
[Link]();
// DO some other operation
} // end main()
}

32
 Shared account object
between 3 threads
class MyThread implements Runnable {
Account account;
public MyThread (Account s) { account = s;}
public void run() { [Link](); }
} // end class MyThread

class YourThread implements Runnable { account

Account account;
public YourThread (Account s) { account = s;}
(shared
public void run() { [Link](); } object)
} // end class YourThread

class HerThread implements Runnable {

Account account;
public HerThread (Account s) { account = s; }
public void run() {[Link](); }
} // end class HerThread
33
Monitor (shared object access):
serializes operation on shared
object
class Account { // the 'monitor'
int balance;

// if 'synchronized' is removed, the outcome is unpredictable

public synchronized void deposit( ) {
// METHOD BODY : balance += deposit_amount;
}

public synchronized void withdraw( ) {

// METHOD BODY: balance -= deposit_amount;
}
public synchronized void enquire( ) {
// METHOD BODY: display balance.
}
}

34
 Multithreaded Server
Multithreaded Server
Server Process
Client
Process Server
Threads

Client Process

User Mode

Kernel Mode
Message Passing
Facility

35
Assignment 1: Multithreaded MathServer
– Demonstrates the use of Sockets and
Threads

A Client Program “sqrt 4.0”

What is sqrt(10)? Multithreaded
MathServer
“2.0”
(sin, cos, sqrt, etc.)
A Client Program
What is sin(10)?

A Client
Program in “C” A Client
What is sin(10)? Program in “C++”
What is sin(10)?

36
A Multithreaded Program
MathThreads

start start start

MathSin MathCos MathTan

join join join

MathThreads

37
 Thread Programming
Thread concurrency/operation
models models

 The master/worker model

 The peer model
 A thread pipeline

38
The master/worker model

Program Resources
Workers
taskX
taskX Files

Master Databases
taskY
taskY
main ( )
Input (Stream) main ( )

Disks
taskZ
taskZ

Special
Devices

39
 The peer model

Program Resources
Workers
Input
Input taskX
taskX Files

Databases
taskY
taskY

Disks
taskZ
taskZ

Special
Devices

40
 A thread Apipeline
thread pipeline

Program Filter Threads

Stage 1 Stage 2 Stage 3
Stage 1 Stage 2 Stage 3

Input (Stream)

Resources Files Files Files

Databases Databases Databases

Disks Disks Disks

Special Devices Special Devices Special Devices

41
 Multithreading and
Multiprocessing Deployment
issues
On Shared and distributed
memory systems

42
 Multithreading -
Multiprocessors
Process
Process Parallelism
Parallelism

CPU
P1
P1

P2 CPU
P2

P3 CPU
P3

tim
tim
ee
No
No of
of execution
execution processes
processes <=
<= the
the
number
number of
of CPUs
CPUs 43
 Multithreading on Uni-
processor
 Concurrency Vs Parallelism
 Process
ProcessConcurrency
Concurrency

P1
P1

P2
P2 CPU

P3
P3

tim
tim
ee

Number
Number of
of Simultaneous
Simultaneous execution
execution units
units >
>
number
number of
of CPUs
CPUs 44
 Multi-Processing (clusters &
grids) and Multi-Threaded
Computing
Threaded Libraries, Multi-threaded I/O

Application

Application Application

Application
CPU
CPU
CPU CPU CPU CPU

Better Response Times in Higher Throughput for

Multiple Application Parallelizeable Applications
Environments
45
 References

 Rajkumar Buyya, Thamarai Selvi,

Xingchen Chu, Mastering OOP
with Java, McGraw Hill (I) Press,
New Delhi, India, 2009.
 Sun Java Tutorial – Concurrency:
 [Link]
essential/concurrency/

46