Multithreading : - PowerPoint PPT Presentation

1 / 32

About This Presentation

Title:

Multithreading :

Description:

It will not be activated by the thread scheduler until it is unblocked ... When a thread calls notifyAll, all threads waiting on the object are unblocked ... – PowerPoint PPT presentation

Number of Views:129

Avg rating:3.0/5.0

Slides: 33

Provided by: csU82

Category:

more less

Transcript and Presenter's Notes

Title: Multithreading :

1

Multithreading
synchronization

2
Solving the Race Condition Problem

A thread must be able to lock an object
temporarily
When a thread has the object locked, no other
thread can modify the state of the object.
In Java, use synchronized methods to do this
Tag all methods that contain thread-sensitive
code with the keyword synchronized

3
Synchronized Methods

public class BankAccount
public synchronized void deposit(double
amount)
. . .
public synchronized void withdraw(double
amount)
. . .
. . .

4
With synchronization, the final balance is always
correct!
5
Synchronized Methods

By declaring both the deposit and withdraw
methods to be synchronized
Our program will run correctly
Only one thread at a time can execute either
method on a given object
When a thread starts one of the methods, it is
guaranteed to execute the method to completion
before another thread can execute a synchronized
method on the same object.

By executing a synchronized method
The thread acquires the object lock.
No other thread can acquire the lock.
No other thread can modify the state of the
object until the first thread is finished.
Every object in Java has a lock associated with
it. Every object can maintain a list of waiting
threads.

7
Visualization of Synchronized Thread Behavior

Imagine the object is a restroom that only one
person can use at a time
The threads are people
If the restroom is empty, a person may enter
If a second person finds the restroom locked, the
second person must wait until it is empty
If multiple people want to gain access to the
restroom , they all wait outside
The people may not form an orderly queue
A randomly chosen person may gain access when the
restroom becomes available again

8
Deadlock

A deadlock occurs if no thread can proceed
because each thread is waiting for another to do
some work first.
In other words, a deadlock occurs when two
threads end up waiting for each other to release
a lock they need. Since neither one can proceed,
neither one can release the lock it holds, and
they both stop running.
When you are synchronizing threads, you must be
careful to avoid deadlock.

BankAccount example
public synchronized void withdraw(double
amount)
while (balance lt amount)
//wait for balance to grow
. . .

The method can lead to deadlock
The thread sleeps to wait for balance to grow,
but it still has the lock
No other thread can execute the synchronized
deposit method
If a thread tries to call deposit, it is blocked
until the withdraw method exits
withdraw method can't exit until it has funds
available
DEADLOCK occurs!

11
Avoiding Deadlock

The wait method temporarily releases the object
lock and deactivates the thread
Restroom analogy
Don't want the person in the restroom to go to
sleep if there is no toilet paper.
Think of the person giving up and leaving
This gives another person a chance to enter and
refill the toilet paper

12
withdraw Method to Avoid Deadlock with wait()

public synchronized void
withdraw(double amount)
throws InterruptedException
while (balance lt amount)
wait()
...

13
Wait and NotifyAll

A thread that calls wait is in a blocked state
It will not be activated by the thread scheduler
until it is unblocked
It is unblocked when another thread calls
notifyAll
When a thread calls notifyAll, all threads
waiting on the object are unblocked
Only the thread that has the lock can call
notifyAll

14
Restroom wait/notifyAll Analogy

The thread calling wait() corresponds to the
person who enters the restroom and finds there is
no toilet paper
The person then leaves the restroom and waits
outside
Other people may enter and leave, but the first
person just waits
Eventually an attendant enters the restroom,
refills the toilet paper, and shouts a
notification
All the waiting people compete for the restroom

15
File BankAccountThreadTest.java

(Modified, Using synchronized methods)
/
This program runs four threads that
deposit and withdraw
money from the same bank account.
/
public class BankAccountThreadTest
public static void main(String args)

BankAccount account new BankAccount()
DepositThread t0
new DepositThread(account, 100)
WithdrawThread t1
new WithdrawThread(account, 100)
DepositThread t2
new DepositThread(account, 100)
WithdrawThread t3
new WithdrawThread(account, 100)
t0.start()
t1.start()
t2.start()
t3.start()
//end main
// end class

17
File BankAccount.java (modified)

/
A bank account has a balance that can be
changed by
deposits and withdrawals.
/
public class BankAccount
/
Constructs a bank account with a zero
balance
/
public BankAccount()
balance 0
/
Deposits money into the bank account.
_at_param amount the amount to deposit
/

public synchronized void deposit(double
amount)
System.out.print("Depositing " amount)
double newBalance balance amount
System.out.println(", new balance is "
newBalance)
balance newBalance
notifyAll()
/
Withdraws money from the bank account.
_at_param amount the amount to withdraw
/
public synchronized void withdraw(double
amount)
throws InterruptedException
while (balance lt amount)
wait()
System.out.print("Withdrawing " amount)
double newBalance balance -
amount
System.out.println(", new balance is "
newBalance)
balance newBalance

/
Gets the current balance of the bank
account.
_at_return the current balance
/
public synchronized double getBalance()
return balance
private double balance
// end class

20
Be careful!

A common error is to have threads call wait
without matching calls to notifyAll by other
threads. Whenever you call wait, ask yourself
which call to notifyAll will notify your thread.
The thread that calls notifyAll must own the lock
on the object on which notifyAll is called.
Otherwise, an IllegalMonitorStateException is
thrown.

21
notify( )

While notifyAll( ) wakes up all threads that are
waiting on the object, notify( ) wakes up only a
single thread that is waiting on the object. If
any threads are waiting on the object, one of
them is chosen to be awakened. The choice is
arbitrary and occurs at the discretion of the
implementation.
It's better to use notifyAll( ).

22
Complex Deadlocks

Using the wait and notifyAll methods does not
solve all deadlocks.
The following is an example.
We have three accounts account0, account1, and
account2 and three transfer threads t0, t1, and
t2.
A transfer thread transfers money from two
accounts into a third.
t0 repeatedly transfers 500 each from account1
and account2 to account0.
t1 repeatedly transfers 500 each from account2
and account0 to account1.
t2 repeatedly transfers 500 each from account0
and account1 to account2.

If the three threads take turns and each thread
executes one iteration before losing control of
the CPU, then the program runs indefinitely

But if it happens that t0 executes two iterations
before t1 and t2 get a chance, then the program
deadlocks

Now none of the three threads can progress, and a
deadlock occurs.
25

Most of the time, the program will carry out the
transfers successfully, but once in a while you
may be able to observe a deadlock.
Programmers who create multithreaded programs
must make an effort to prove rigorously why their
threads cannot deadlock no matter in which order
they are executed.
Running a few experiments is not enough. It can
be misleading.

26
File BankAccountThreadTest.java

/
This program uses three threads that transfer
money between three accounts. It can occasionally
deadlock.
/
public class BankAccountThreadTest
public static void main(String args)
BankAccount account0 new
BankAccount(1000)
BankAccount account1 new
BankAccount(1000)
BankAccount account2 new
BankAccount(1000)
//... Put your code here ...