HO CHI MINH UNIVERSITY OF INDUSTRY

Objectives
 What are Threads?
 Interrupting threads
 Thread properties
 Threads priorities
 Synchronization
 Callables and Futures
 Threads and Swing

1
 HO CHI MINH UNIVERSITY OF INDUSTRY

 What are Threads?

 The smallest unit of executable code

that performs a particular task.

• An application can be divided into multiple

tasks and each task can be assigned to a

thread.
 Many threads executing simultaneously

is termed as Multithreading.
• Appears that the processes are running

concurrently, but it isn’t so.

2
 HO CHI MINH UNIVERSITY OF INDUSTRY

 When Java programs execute, there is

always one thread running and that is the
main thread.
• It is this thread from which child threads

are created.
• Program is terminated when main thread

stops execution.
• Main thread can be controlled through

Thread objects.
• Reference of the main thread can be

obtained by calling the currentThread()

method of the Thread class.
3
 HO CHI MINH UNIVERSITY OF INDUSTRY

 Why Multithreading?
 Increases performance of single-processor
system, as it reduces the CPU idle time.
 Multithreading encourages faster execution of

a program
 Multithreading introduces the concept of

parallel processing

4
 HO CHI MINH UNIVERSITY OF INDUSTRY

 Creating Thread
 Two ways:
1. Declare a class that is a sub-class of the
class Thread defined in java.lang
package:

class mythread extends Thread

2. Declare a class that implements the
Runnable interface (recommended):

class mythread implements Runnable

5
 HO CHI MINH UNIVERSITY OF INDUSTRY

 Creating Thread

We should implements Runnable because we

could extend another class and share object
Tips: Java allows single inherit only

6
 HO CHI MINH UNIVERSITY OF INDUSTRY

 Creating Thread

1. Override method run of Thread class.

2. The code inside is the task assign to
thread when running.

7
 HO CHI MINH UNIVERSITY OF INDUSTRY

 Creating Thread

1. Override method run of Thread class.

2. The code inside is the task assign to
thread when running.

8
 HO CHI MINH UNIVERSITY OF INDUSTRY

 Running Thread
 After a new thread has been initiated, we use
the start() method to start the thread
 Otherwise it is an empty Thread object with no

system resources allocated.

 When start() method is invoked, the system

resources required to run the thread is created
and schedules the thread to run.
 It then calls the thread’s run() method.
9
 HO CHI MINH UNIVERSITY OF INDUSTRY

 Running Thread

Output

10
 HO CHI MINH UNIVERSITY OF INDUSTRY

 Thread Properties
• Thread States :
– New
– Runnable
– Blocked
– Dead

11
 HO CHI MINH UNIVERSITY OF INDUSTRY

 Thread Properties

12
 HO CHI MINH UNIVERSITY OF INDUSTRY

 Thread Properties

Pause for a while for

another thread run

13
 HO CHI MINH UNIVERSITY OF INDUSTRY

 Thread Properties

Pause for a while for

another thread run

14
 HO CHI MINH UNIVERSITY OF INDUSTRY

 Thread Properties

Output

15
 HO CHI MINH UNIVERSITY OF INDUSTRY

 Methods of Thread class

• getName() and setName()
• start() – a thread object is in a runnable
state
• run() – is executed once the start method
is invoked
• sleep() – suspends the execution of the
current thread for a specified period of time

16
 HO CHI MINH UNIVERSITY OF INDUSTRY

Methods of Thread class

• setPriority() and getPriority()
 The constants :
NORM_PRIORITY – value is 5 (default)
MAX_PRIORITY – value is 10
MIN_PRIORITY – value is 1
• Priorities for carrying out activities changes at
times.
• We may have to run a thread of higher
importance without stopping or suspending the
current running thread.
• Thread priorities play an important role in such a

situation.
17
 HO CHI MINH UNIVERSITY OF INDUSTRY

 Methods of Thread class

• The highest-priority runnable thread keeps
running until:
– It yields by calling the yield() method
– It ceases to be runnable (either by dying or
by entering the blocked state)
– A higher-priority thread has become
runnable.
• We can use follow method to set priority of
Thread
void setPriority(int newP)

18
 HO CHI MINH UNIVERSITY OF INDUSTRY

 Daemon Thread
• Two types of threads in Java:
1. User threads:
• Created by the user
2. Daemon threads:
• Threads that work in the background
providing service to other threads
(e.g. – the garbage collector thread)

19
 HO CHI MINH UNIVERSITY OF INDUSTRY

 Daemon Thread
• When user thread exits, JVM checks to
find out if any other thread is running.
– If there are, it will schedule the next
thread.
– If the only executing threads are
daemon threads, it exits.
• We can set a thread to be a Daemon if we
do not want the main program to wait until
a thread ends.

20
 HO CHI MINH UNIVERSITY OF INDUSTRY

• “isAlive()" Method
– Use to find out whether a specific thread is
running or not.
• “join()" Method
– Causes the current thread to wait until the thread
on which it is called terminates.
– Allows specifying the maximum amount of time
that the program should wait for the particular
thread to terminate.
– It throws InterruptedException if another thread
interrupts it.
– The calling thread waits until the specified thread
terminates.
21
 HO CHI MINH UNIVERSITY OF INDUSTRY

 Interrupting Thread
• There is no longer a way to force a thread
to terminate.
• The interrupt method can be used to
request termination of a thread.
• Checking one thread is interrupted:
Thread.currentThread().isInterrupted() 
• If a thread is blocked, it cannot check the
interrupted status. This is where the
InterruptedException comes in.

22
 HO CHI MINH UNIVERSITY OF INDUSTRY

 Interrupting Thread
public void run()
{ Pattern for interrupting an thread
try{ . . .
while (more work to do){
do more work
}
}
catch(InterruptedException exception){
// thread was interrupted during sleep or wait
}
finally{
cleanup, if required
}
// exit run method and terminate thread
}
23
 HO CHI MINH UNIVERSITY OF INDUSTRY

 Thread Synchronization
• What happens if two threads have access to
the same object and each calls a method
that modifies the state of the object?
• In such a case, data may become
inconsistent.
• Situation is often called a race condition.
• To avoid simultaneous access of a shared
object by multiple threads, you must learn
how to synchronize the access.

24
 HO CHI MINH UNIVERSITY OF INDUSTRY

 Thread Synchronization - 1st approach

• Thread Communication Without Synchronization
View follow example: UnsynchBankTest.java
• There are some things wrong in this Bank.
• The Race Condition Explained:
– The problem is that these are not atomic
operations. View follow figure : p.51
– The real problem is that the work of the
transfer method can be interrupted in the
middle. If we could ensure that the method
runs to completion before the thread loses
control, then the state of the bank account
object would not be corrupted.
25
 HO CHI MINH UNIVERSITY OF INDUSTRY

 Thread Synchronization - 1st approach

26
 HO CHI MINH UNIVERSITY OF INDUSTRY

 Thread Synchronization - 1st approach

• Synchronization is based on the concept of
monitor.
– A monitor is an object that is used as a mutually
exclusive lock.
• Only one thread can enter a monitor:
– When one thread enters the monitor, it means that the
thread has acquired a lock
– All other threads must wait till that thread exits the
monitor.
• For a thread to enter the monitor of an object:
– The programmer may invoke a method created using
the synchronized keyword (implicit synchronize).
– Or using explicit lock objects.
27
 HO CHI MINH UNIVERSITY OF INDUSTRY

 Thread Synchronization - 1st approach

• Concurrency mechanism:
– Simply tag any operation that should not be
interrupted as synchronized, for example :
public synchronized void transfer
(int from, int to,int amount)
– When one thread calls a synchronized
method, it is guaranteed that the method will
finish before another thread can execute any
synchronized method on the same object.

28
 HO CHI MINH UNIVERSITY OF INDUSTRY

 Thread Synchronization - 1st approach

29
 HO CHI MINH UNIVERSITY OF INDUSTRY

 Thread Synchronization - 1st approach

• When a thread calls a synchronized method,
the object becomes "locked."
• Periodically, the thread scheduler activates the
threads that are waiting for the lock to open.
• Other threads are still free to call
unsynchronized methods on a locked object.
• When a thread leaves a synchronized method
by throwing an exception, it still relinquishes
the object lock.

30
 HO CHI MINH UNIVERSITY OF INDUSTRY

 Thread Synchronization - 1st approach

• If a thread owns the lock of an object and it
calls another synchronized method of the
same object, then that method is
automatically granted access. The thread only
relinquishes the lock when it exits the last
synchronized method.

31
 HO CHI MINH UNIVERSITY OF INDUSTRY

 Thread Synchronization - 1st approach

This mechanism ensures that there is a smooth
transition of a particular resource between two
competitive threads.
It also oversees the condition in a program where
one thread is:
Allowed to wait for the lock.
Notified to end its waiting state and get the lock
When a thread executes a call to wait, it surrenders
the object lock and enters a wait list for that object.
To remove a thread from the wait list, some other
thread must make a call to notifyAll or notify, on the
same object.

32
 HO CHI MINH UNIVERSITY OF INDUSTRY

Thread Synchronization - 1st approach

notify() First thread

notify()
wakes up or
notifies the
first thread.

notifyAll() Thread 2
notifyAll()
wakes up or Thread 1
notifies all the
Thread 3
threads that
called wait( ) on
the same object. Java Simplified / Session 16 / 33 of 32

33
 HO CHI MINH UNIVERSITY OF INDUSTRY

 Thread Synchronization - 1st approach

– Syntax : synchronized (object){
//do your work
}
– Example :
public void run(){
try
{
while (true)
{
synchronized (bank) {
//do your work
}
}
}
catch (InterruptedException e) {}
}
34
 HO CHI MINH UNIVERSITY OF INDUSTRY

 Thread Synchronization - 1st approach

 If one thread calls a synchronized static
method of a class, all synchronized
static methods of the class are blocked
until the first call returns.

 Example :
public static synchronized getInstance()

35
 HO CHI MINH UNIVERSITY OF INDUSTRY

 Thread Synchronization – 2nd approach

• The basic outline for protecting a code block with a
ReentrantLock is:
private Lock bankLock;
private Condition sufficientFunds;
bankLock = new ReentrantLock();
sufficientFunds = bankLock.newCondition();
bankLock.lock();
try {
while (accounts[from] < amount)
sufficientFunds.await();
sufficientFunds.signalAll();
}
finally{
bankLock.unlock();
}
36
 HO CHI MINH UNIVERSITY OF INDUSTRY

 Thread Synchronization – 2nd approach

• This construct guarantees that only one
thread at a time can enter the critical section.
• As soon as one thread locks the lock object, no
other thread can get past the lock statement.
• When other threads call lock, they are blocked
until the first thread unlocks the lock object.

37
 HO CHI MINH UNIVERSITY OF INDUSTRY

 Thread Synchronization – 2nd approach

Condition Objects
 See code below:
if (bank.getBalance(from) >= amount)
bank.transfer(from, to, amount);
 It is entirely possible that the current thread will be
deactivated between the successful outcome of the test
and the call to transfer:
if (bank.getBalance(from) >= amount)
// thread might be deactivated at this point
bank.transfer(from, to, amount);
 By the time the thread is running again, the account
balance may have fallen below the withdrawal amount.

38
 HO CHI MINH UNIVERSITY OF INDUSTRY

 Thread Synchronization – 2nd approach

Condition Objects

39
 HO CHI MINH UNIVERSITY OF INDUSTRY

 Thread Synchronization – 2nd approach

Condition Objects
• What do we do when there is not enough
money in the account?
• We wait until some other thread has added
funds. But this thread has just gained exclusive
access to the bankLock, so no other thread
has a chance to make a deposit.
• The solution is : condition objects
– A lock object can have one or more
associated condition objects.

40
 HO CHI MINH UNIVERSITY OF INDUSTRY

 Thread Synchronization – 2nd approach

Condition Objects

41
 HO CHI MINH UNIVERSITY OF INDUSTRY

 Thread Synchronization – 2nd approach

Condition Objects

• If the Transfer method finds that sufficient

funds are not available, it calls

=>The current thread is now blocked and gives

up the lock. This lets in another thread that can,
we hope, increase the account balance

42
 HO CHI MINH UNIVERSITY OF INDUSTRY

 Thread Synchronization – 2nd approach

Condition Objects
• There is an essential difference between a
thread that is waiting to acquire a lock and a
thread that has called await.
• Once a thread calls the await method, it
enters a wait set for that condition.
• Thread is not unblocked when the lock is
available.
• Instead, it stays blocked until another thread
has called the signalAll method on the same
condition.
43
 HO CHI MINH UNIVERSITY OF INDUSTRY

 Thread Synchronization – 2nd approach

Condition Objects
• The signalAll method call unblocks all threads
that are waiting for the condition.
• When the threads are removed from the wait
set, they are again runnable and the scheduler
will eventually activate them again.

44
 HO CHI MINH UNIVERSITY OF INDUSTRY

 Thread Synchronization – 2nd approach

Fainess
• A fair lock favors the thread that has been
waiting for the longest time.
• By default, locks are not required to be fair.
• You can specify that you want a fair locking
policy:
Lock fairLock = new ReentrantLock(true);

• Fair locks are a lot slower than regular locks.

• You should only enable fair locking if you have a
specific reason why fairness is essential for your
problem.
45
 HO CHI MINH UNIVERSITY OF INDUSTRY

 Thread Synchronization – 2nd approach

Fainess
• The tryLock method tries to acquire a lock and
returns true if it was successful. Otherwise, it
immediately returns false.

• You can call tryLock with a timeout parameter, like

this:
if(myLock.tryLock(100, TimeUnit.MILLISECONDS))

• TimeUnit is an enumeration with values SECONDS,

MILLISECONDS, MICROSECONDS, and NANOSECONDS.
46
 HO CHI MINH UNIVERSITY OF INDUSTRY

 Deadlocks
Analyzing following situation

47
 HO CHI MINH UNIVERSITY OF INDUSTRY

 Deadlocks
• If all threads in an application are blocked. The
system has deadlocked.
• Unfortunately, there is nothing in the Java
programming language to avoid or break these
deadlocks.
• You must design your threads to ensure that a
deadlock situation cannot occur.
• Notify/notifyAll method can unblock thread(s).

48
 HO CHI MINH UNIVERSITY OF INDUSTRY

 Callables and Futures

• A Runnable encapsulates a task that runs
asynchronously; you can think of it as an
asynchronous method with no parameters and
no return value.
• Drawback of Runnable:
– Cannot return any type (of run method)
– No parameters (of run method)
– Processing exception locally.
• So, we need another mechanic: Callable
• The Callable interface is a parameterized type,
with a single method call:
49
 HO CHI MINH UNIVERSITY OF INDUSTRY

 Callables and Futures

50
 HO CHI MINH UNIVERSITY OF INDUSTRY

 Callables and Futures

• A Future object holds the result of an asynchronous
computation.
• You use a Future object so that you can start a
computation, give the result to someone, and forget
about it.
• The owner of the Future object can obtain the result
when it is ready.

51
 HO CHI MINH UNIVERSITY OF INDUSTRY

 Callables and Futures

• The FutureTask wrapper is a convenient
mechanism for turning a Callable into both a
Future and a Runnable it implements both
interfaces.

52
 HO CHI MINH UNIVERSITY OF INDUSTRY

 Callables and Futures

• Thread is a special and interesting property of Java
– For building a single program to perform more than one
task at the same time (multithreading program)

• Other advanced technique to use multithreading is

Callable
– The best technique to handling multithreading.

53
 HO CHI MINH UNIVERSITY OF INDUSTRY

 Threads and Swing

54
 HO CHI MINH UNIVERSITY OF INDUSTRY

 Threads and Swing

55
 HO CHI MINH UNIVERSITY OF INDUSTRY

END
56