Multithreaded Programming in

Java

1
 Levels of Parallelism
Code-Granularity
Code Item
Sockets Task i-l Task i Task i+1 Large grain
(task level)
Program

func1 ( ) func2 ( ) func3 ( )

{ { {
.... .... .... Medium grain
Threads .... .... .... (control level)
} } } Function (thread)

a ( 0 ) =.. a ( 1 )=.. a ( 2 )=.. Fine grain

Compilers b ( 0 ) =.. b ( 1 )=.. b ( 2 )=.. (data level)
Loop (Compiler)

CPU + x Load Very fine grain

(multiple issue)
2
With hardware
 Multitasking
 Process based multitasking
 Several independent process executing
simultaneously
 Os based concept-advatages for os and not
programs
 Download a file,run java program,open browser

3
 Multithreading

 Thread based multitasking

 Same program-simultaneously executing
multiple task where each task is a piece of
independent code
 Programmatic level
 Word-edit,print,checking
 Games-different objects on a platform
 Road rash-different bikes/objects
 Youtube –download 4 files
4
 A single threaded program

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

}
}
5
 A Multithreaded Program
Threads may switch or
exchange data/results

A thread provides the

Main Thread
mechanism for running a
task.

Each task is an instance of

start
start the Runnable interface,
start
also called a runnable object.

A thread is essentially an
object that facilitates the
execution of a task
Thread A Thread B Thread C

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

Single-threaded Process Multiplethreaded Process

Threads of
Execution

Single instruction stream Multiple instruction stream

Common
Address Space

7
single-threaded vs multithreaded programs

{ A();
newThreads {
{ A(); A1(); A2(); A3();
{ A1(); A2(); A3() };
B1(); B2(); }
{B1(); B2() }
}
}
9
10
MULTI-THREADED
APPLICATIONS
11
 Web/Internet Applications:
Serving Many Users Simultaneously
PC client

Internet
Server
Local Area Network

PDA
12
Multithreaded Server: For Serving
Multiple Clients Concurrently

Client 1 Process Server Process

Server
Threads
 Internet

Client 2 Process

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

Editing Thread

14
Multithreaded/Parallel File Copy

reader()
{ writer()
- - - - - - - - - - buff[0] {
lock(buff[i]); - - - - - - - - - -
read(src,buff[i]); buff[1] lock(buff[i]);
unlock(buff[i]); write(src,buff[i]);
- - - - - - - - - - unlock(buff[i]);
} - - - - - - - - - -
}

Cooperative Parallel Synchronized

Threads 15
Example application-Process
Threads in word application
18
 Process Vs Threads
 Process executables which runs in
separate memory space
 Threads  small process which shared
memory space within a process

PROCESS
THREAD THREAD
Threads

20
Threads

21
Thread ecology in a java program
started by java from main(String[])

started by main thread

started by B thread

lifetime of C thread
 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.
23
 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

24
 Define and launch a java thread
 Each Java Run time thread is encapsulated in a
java.lang.Thread instance.
 Two ways to define a thread:
1. Extend the Thread class
2. Implement the Runnable interface :
package java.lang;
public interface Runnable { public void run() ; }
 Steps for extending the Thread class:
1. Subclass the Thread class;
2. Override the default Thread method run(), which is the entry point
of the thread, like the main(String[]) method in a java program.
 Threading Mechanisms...
 Create a class that extends the Thread class
 Create a class that implements the Runnable
interface

26
 The Thread Class
public class Thread extends Object implements Runnable {
public Thread();
public Thread(String name);
public Thread(Runnable target);
public Thread(Runnable target,
String name);
public Thread(Runnable target,
String name, long stackSize);

public void run();

public void start();
...
}
 An Overview of the Thread Methods
 Thread-related methods
 Constructors
 Thread() - Creates a thread with an auto-numbered name
of format Thread-1, Thread-2...
 Thread( threadName ) - Creates a thread with name
 run
 Does “work” of a thread – What does this mean?
 Can be overridden in subclass of Thread or in Runnable
object (more on interface Runnable elsewhere)
 start
 Launches thread, then returns to caller
 Calls run
 Error to call start twice for same thread

28
1st method: Extending Thread class
 Threads are implemented as objects that contains
a method called run()
class MyThread extends Thread
{
public void run()
{
// thread body of execution
}
}
 Create a thread:
MyThread thr1 = new MyThread();
 Start Execution of threads:
thr1.start(); 29
 An example
class MyThread extends Thread {

public void run() {

System.out.println(" this thread is running ... ");
}
}

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

30
 2nd method: Threads by implementing
Runnable interface
class MyThread implements Runnable
{
.....
public void run()
{
// thread body of execution
}
}
 Creating Object:

MyThread myObject = new MyThread();

 Creating Thread Object:

 A Runnable object can be wrapped up into a Thread object

Thread thr1 = new Thread( myObject );

 Start Execution:

thr1.start(); 31
 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();
}
}

32
 Need for Runnable
// Example:
public class Print2Console extends Thread {
public void run() { // run() is to a thread what main() is to a java program
for (int b = -128; b < 128; b++) out.println(b); }
… // additional methods, fields …
}
 Impement the Runnable interface if you need a parent
class:
// by extending JTextArea we can reuse all existing code of JTextArea

public class Print2GUI extend JTextArea implement Runnable {

public void run() {
for (int b = -128; b < 128; b++) append( Integer.toString(b) + “\n” ); }
}
34
A Program with Three Java Threads

 Write a program that creates 3 threads

35
 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");

}

36
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");

}
37
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");

}
38
class ThreadTest
{
public static void main(String args[])

{
new A().start();
new B().start();
new C().start();

} 39
 Run 1
 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

40
 Run2
 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

41
You decided to modify the application by using multiple threads to reduce the computation time. For this,
accept the number of counters or threads at the beginning of the problem and get the string for each
counter or thread. Create a thread by extending the Thread class and take the user entered string as
input. Each thread calculates the character frequency for the word assigned to that thread. All the counts
are stored locally in the thread and once all the threads are completed print the character frequency for
each of the threads.

Create a class Main.

Input and Output format:

Refer to sample Input and Output for formatting specifications.

Sample input and output:

[All Texts in bold corresponds to the input and rest are output]

Enter Number of Counters :

2
Enter text for counter 1 :
FrequencyCounter
Enter text for counter 2 :
JavaTheCompleteReference
Counter 1 Result :
C:1 F:1 c:1 e:3 n:2 o:1 q:1 r:2 t:1 u:2 y:1
Counter 2 Result :
C:1 J:1 R:1 T:1 a:2 c:1 e:7 f:1 h:1 l:1 m:1 n:1 o:1 p:1 r:1 t:1 v:1
42
 Life cycle of A Thread

States:
1. Newborn state

2. Runnable state

3. Running state

4. Blocked state

5. Dead state
 Thread States: Life Cycle of a Thread
 Born state
 Thread just created
 When start called, enters ready state
 Ready state (runnable state)
 when start() method is called on the thread object. A thread in
runnable state is scheduled to run by JVM but it may not start
running until it gets CPU cycle.
 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

44
Newborn state:
 when we create a thread object , the thread is born
 not yet scheduled for running
Only following methods can be used:
1. start()
2. stop()
Newborn
start stop

Runnable
state Dead state

if any other method is invoked at this stage, an exception will be

thrown
Runnable state:
 Means thread is ready for execution and waiting for
availability of the processor
 Threads will be in queue, processed based on priority
 Equal priority threads have been assigned time slots for
execution  time-slicing
 Relinquish control from one thread to another of same
priority can be given before its turn comes , by using
yield() method yield()

t1 t2 t3 t4

Running Thread Runnable Threads

Running state:
 Means that the processor has given its time to the thread
for its execution
 Thread runs until the control given to some other thread
Situations when running thread may relinquish its control:
1. Suspended using suspend() method  suspend for some
time due to certain reason, but not to kill the thread
suspend()

resume()
. . .

Running Runnable Suspended

2. Sleep(time) thread is out of the queue this time period
 Entered when sleep method called

 Cannot use processor

 Enters ready state after sleep time expires

sleep(t)

after(t)
. . .

Running Runnable Sleeping

 3. Wait until some event occurs
 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

wait()

notify()
. . .

Running Runnable Waiting

49
Blocked state/Waiting
 Blocked thread is considered “not runnable” but
not dead and fully qualified to run again
 Entered from running state
 Blocked thread cannot use processor, even if available
 Common reason for blocked state - waiting on I/O request
 waiting to acquire a monitor lock to enter or re-enter a
synchronized block/method
 suspend(),Sleep(),wait(),join()
Dead state
 Running thread ends when it completed executing its run() method
 Also using stop()
 All stages running,runnable,blocked
 The life cycle of a Java thread
runnable
get the lock blocked/waiting

start() resume()
new Thread(…)
not-running thread t terminates
(ready) sleep done
o.notify(), o.notifyAll()
interrupt()
(set bit) interrupt()
yield(), or
preempty scheduled
by OS (throw exception)
by OS
o.wait()
sleep(…)

running t.join()
stop(),
terminated run() exits suspend()
normally or blocked by lock
abnormally
public class ThreadDemo extends Thread
{
public void run()
{
System.out.println("Thread is running !!");
}
public static void main(String[] args)
{
ThreadDemo t1 = new ThreadDemo();
ThreadDemo t2 = new ThreadDemo();
System.out.println("T1 ==> " + t1.getState());
System.out.println("T2 ==> " + t2.getState());

52
t1.start();
System.out.println("T1 ==> " + t1.getState());
System.out.println("T2 ==> " + t2.getState());
t2.start();
System.out.println("T1 ==> " + t1.getState());
System.out.println("T2 ==> " + t2.getState()); } }

53
 1 ==> NEW
 T2 ==> NEW
 T1 ==> RUNNABLE
 T2 ==> NEW
 T1 ==> RUNNABLE
 T2 ==> RUNNABLE
 Thread is running !!
 Thread is running !! 54
 isAlive()
 TwoThreadAlive tt = new TwoThreadAlive();
tt.setName("Thread"); System.out.println("before
start(), tt.isAlive()=" + tt.isAlive());
 tt.start();
 System.out.println("just after start(), tt.isAlive()="
+ tt.isAlive());

55
 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

56
 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");

}
57
 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");
} 58
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");

} 59