JavaThreads File - Dr. Manal Helal Moodle Site

Document technical information

Format ppt
Size 1.9 MB
First found May 22, 2018

Document content analysis

Category Also themed
Language
English
Type
not defined
Concepts
no text concepts found

Persons

Organizations

Places

Transcript

CS244: Advanced Programming
Applications
Lecture 3: Multithreading – Chapter 32
Dr. Manal Helal, Spring 2014
http://moodle.manalhelal.com
Multithreading and Parallel
Programming - Chapter 32
2
OOP in Java : © W. Milner 2005 : Slide 2

Learning
Objectives
To get an overview of multithreading (§32.2).
 To develop task classes by implementing the Runnable interface (§32.3).
 To create threads to run tasks using the Thread class (§32.3).
 To control threads using the methods in the Thread class (§32.4).
 To control animations using threads (§32.5, §32.7).
 To run code in the event dispatch thread (§32.6).
 To execute tasks in a thread pool (§32.8).
 To use synchronized methods or blocks to synchronize threads to avoid race conditions (§32.9).
 To synchronize threads using locks (§32.10). (optional)
 To facilitate thread communications using conditions on locks (§§32.11-32.12).








(optional)
To use blocking queues to synchronize access to an array queue, linked queue, and
priority queue (§32.13). (optional)
To restrict the number of accesses to a shared resource using semaphores (§32.14).
(optional)
To use the resource-ordering technique to avoid deadlocks (§32.15).
To describe the life cycle of a thread (§32.16).
To create synchronized collections using the static methods in the Collections class
(§32.17). (optional)
To develop parallel programs using the Fork/Join Framework (§32.18). (optional)
To run time-consuming tasks in a SwingWorker rather than in the event dispatch
3
thread (§32.19). (optional)
OOP in Java : © W. Milner 2005 : Slide 3
To display the completion status of a task using JProgressBar (§32.20).
Threads Concept
Multiple
threads on
multiple
CPUs
Multiple
threads
sharing a
single CPU
Thread 1
Thread 2
Thread 3
Thread 1
Thread 2
Thread 3
4
OOP in Java : © W. Milner 2005 : Slide 4
Creating Tasks and Threads
java.lang.Runnable
TaskClass
// Custom task class
public class TaskClass implements Runnable {
...
public TaskClass(...) {
...
}
// Client class
public class Client {
...
public void someMethod() {
...
// Create an instance of TaskClass
TaskClass task = new TaskClass(...);
// Create a thread
Thread thread = new Thread(task);
// Implement the run method in Runnable
public void run() {
// Tell system how to run custom thread
...
}
...
}
// Start a thread
thread.start();
...
}
...
}
5
OOP in Java : © W. Milner 2005 : Slide 5
Using the
Runnable
Interface to Create
and Launch
Threads
 Objective: Create and run three
threads:
 The first thread prints the
letter a 100 times.
 The second thread prints the
letter b 100 times.
 The third thread prints the
integers 1 through 100.
TaskThreadDemo
public class TaskThreadDemo {
public static void main(String[] args) {
// Create tasks
Runnable printA = new PrintChar(‘a’, 100);
Runnable printB = new PrintChar(‘b’, 100);
Runnable print100 = new PrintNum(100);
Thread thread1 = new Thread(printA);
Thread thread2 = new Thread(printB);
Thread thread3 = new Thread(print100);
// Start threads
thread1.start();
thread2.start();
thread3.start();
}
}
/* The task class for printing a char */
class PrintChar implements Runnable {
private char my_c;
public PrintChar (char c) {
my_c = c;
}
/** Tell the thread how to run */
public void run() {
// …
}
}
/*The task class for printing number from 1:n */
class PrintNum implements Runnable {
private int lastNum;
public PrintNum(int n) {
lastNum = n;
}
/** Tell the thread how to run */
public void run() {
//6 …
}
OOP in Java : © W. Milner 2005 : Slide 6
}
Exercise: Replace the start() method
with the run()
thread1.start();
thread2.start();
thread3.start();
Replaced by
print100.run();
printA.run();
printB.start();
Invoking run() directly merely executes this method in the
same thread; no new thread is started.
OOP in Java : © W. Milner 2005 : Slide 7
Correct the errors:
(a) new Test() is recursively called inside the constructor. To fix it,
delete the highlighted line and use new Thread(this).start(). (b) An
illegal java.lang.IllegalThreadStateException may be thrown because
you just started thread and thread might have not yet finished before
you start it again. To fix it, delete one t.start().
OOP in Java : © W. Milner 2005 : Slide 8
The Thread Class
«interface»
java.lang.Runnable
java.lang.Thread
+Thread()
Creates a default thread.
+Thread(task: Runnable)
Creates a thread for a specified task.
+start(): void
Starts the thread that causes the run() method to be invoked by the JVM.
+isAlive(): boolean
Tests whether the thread is currently running.
+setPriority(p: int): void
Sets priority p (ranging from 1 to 10) for this thread.
+join(): void
Waits for this thread to finish.
+sleep(millis: long): void
Puts the runnable object to sleep for a specified time in milliseconds.
+yield(): void
Causes this thread to temporarily pause and allow other threads to execute.
+interrupt(): void
Interrupts this thread.
9
OOP in Java : © W. Milner 2005 : Slide 9
The Static yield() Method
You can use the yield() method to temporarily release time for
other threads. For example, suppose you modify the code in Lines
53-57 in TaskThreadDemo.java as follows:
public void run() {
for (int i = 1; i <= lastNum; i++) {
System.out.print(" " + i);
Thread.yield();
}
}
Every time a number is printed, the print100 thread is yielded.
So, the numbers are printed after the characters.
10
OOP in Java : © W. Milner 2005 : Slide 10
The Static sleep(milliseconds) Method
The sleep(long mills) method puts the thread to sleep for the specified time in
milliseconds. For example, suppose you modify the code in Lines 53-57 in
TaskThreadDemo.java as follows:
public void run() {
for (int i = 1; i <= lastNum; i++) {
System.out.print(" " + i);
try {
if (i >= 50) Thread.sleep(1);
}
catch (InterruptedException ex) {
}
}
}
Every time a number (>= 50) is printed, the print100 thread is put to sleep
for 1 millisecond.
11
OOP in Java : © W. Milner 2005 : Slide 11
The join() Method
You can use the join() method to force one thread to wait for another thread
to finish. For example, suppose you modify the code in Lines 53-57 in
TaskThreadDemo.java as follows:
Thread
public void run() {
print100
Thread thread4 = new Thread(
new PrintChar('c', 40));
-char token
thread4.start();
try {
+getToken
for (int i = 1; i <= lastNum; i++) {
printA.join()
+setToken
System.out.print(" " + i);
+paintCompo
Wait for printA
-char
if (i == 50) thread4.join();
net token
to finish+mouseClicke
}
+getToken
d
}
+setToken
+getToken
catch (InterruptedException ex) {
+setToken +paintCompone
}
t
+paintComponet
}
+mouseClicked
+mouseClicked
Thread
printA
-char token
+getToken
+setToken
+paintCompo
net
+mouseClicke
d
printA finished
-char token
The numbers after 50 are printed after thread thread4 is finished.
12
OOP in Java : © W. Milner 2005 : Slide 12
isAlive(), interrupt(), and isInterrupted()
The isAlive() method is used to find out the state of a thread. It
returns true if a thread is in the Ready, Blocked, or Running state;
it returns false if a thread is new and has not started or if it is
finished.
The interrupt() method interrupts a thread in the following way:
If a thread is currently in the Ready or Running state, its
interrupted flag is set; if a thread is currently blocked, it is
awakened and enters the Ready state, and an
java.io.InterruptedException is thrown.
The isInterrupt() method tests whether the thread is interrupted.
13
OOP in Java : © W. Milner 2005 : Slide 13
The deprecated stop(), suspend(), and
resume() Methods
NOTE: The Thread class also contains the stop(), suspend(), and resume()
methods. As of Java 2, these methods are deprecated (or outdated) because they
are known to be inherently unsafe.You should assign null to a Thread variable
to indicate that it is stopped rather than use the stop() method.
14
OOP in Java : © W. Milner 2005 : Slide 14
Thread Priority
 Each thread is assigned a default priority of
Thread.NORM_PRIORITY. You can reset the
priority using setPriority(int priority).
 Some constants for priorities include
Thread.MIN_PRIORITY
Thread.MAX_PRIORITY
Thread.NORM_PRIORITY
15
OOP in Java : © W. Milner 2005 : Slide 15
Example:
Flashing
Text
FlashingText
import javax.swing.*;
public class FlashingText extends JApplet implements Runnable
{
private JLabel jlblText = new JLabel("Welcome",
JLabel.CENTER);
public FlashingText() {
add (jlblText);
new Thread(this).start();
}
/** Set the text on/off every 200 milliseconds */
public void run() {
try {
while (true) {
if (jlblText.getText() == null)
jlblText.setText("Welcome");
else
jlblText.setText(null);
Thread.sleep(200);
}
}
catch (InterruptedException ex) {/*…*/}
}
/** Main method */
public static void main(String[] args){
SwingUtilities.invokeLater(new Runnable() {
public void run() {
JFrame frame = new JFrame("FlashingText");
frame.add(new FlashingText());
frame.setLocationRelativeTo(null);
frame.setSize(200, 200);
frame.setVisible(true);
}
});
}
16
}
OOP in Java : © W. Milner 2005 : Slide 16
GUI Event Dispatcher Thread
GUI event handling and painting code executes in a single
thread, called the event dispatcher thread. This ensures that each
event handler finishes executing before the next one executes
and the painting isn’t interrupted by events.
17
OOP in Java : © W. Milner 2005 : Slide 17
invokeLater and invokeAndWait
In certain situations, you need to run the code in the event dispatcher
thread to avoid possible deadlock.You can use the static methods,
invokeLater and invokeAndWait, in the javax.swing.SwingUtilities class
to run the code in the event dispatcher thread.You must put this code in
the run method of a Runnable object and specify the Runnable object as
the argument to invokeLater and invokeAndWait. The invokeLater
method returns immediately, without waiting for the event dispatcher
thread to execute the code. The invokeAndWait method is just like
invokeLater, except that invokeAndWait doesn't return until the eventdispatching thread has executed the specified code.
18
OOP in Java : © W. Milner 2005 : Slide 18
Launch Application from Main Method
So far, you have launched your GUI application from the main
method by creating a frame and making it visible. This works fine
for most applications. In certain situations, however, it could cause
problems. To avoid possible thread deadlock, you should launch GUI
creation from the event dispatcher thread as follows:
public static void main(String[] args) {
SwingUtilities.invokeLater(new Runnable() {
public void run() {
// Place the code for creating a frame and setting it properties
}
});
}
19
OOP in Java : © W. Milner 2005 : Slide 19
Case Study: Clock with Audio (Optional)
The example creates an applet that displays a running clock and
announces the time at one-minute intervals. For example, if the
current time is 6:30:00, the applet announces, "six o’clock thirty
minutes a.m." If the current time is 20:20:00, the applet announces,
"eight o’clock twenty minutes p.m." Also add a label to display the
digital time.
ClockWithAudio
20
OOP in Java : © W. Milner 2005 : Slide 20
Run Audio on Separate Thread
When you run the preceding program, you will notice that the second
hand does not display at the first, second, and third seconds of the
minute. This is because sleep(1500) is invoked twice in the
announceTime() method, which takes three seconds to announce the
time at the beginning of each minute. Thus, the next action event is
delayed for three seconds during the first three seconds of each
minute. As a result of this delay, the time is not updated and the clock
was not repainted for these three seconds. To fix this problem, you
should announce the time on a separate thread. This can be
accomplished by modifying the announceTime method.
ClockWithAudioOnSeparateThread
21
OOP in Java : © W. Milner 2005 : Slide 21
Thread Pools
Starting a new thread for each task could limit throughput and cause
poor performance. A thread pool is ideal to manage the number of
tasks executing concurrently. JDK 1.5 uses the Executor interface for
executing tasks in a thread pool and the ExecutorService interface for
managing and controlling tasks. ExecutorService is a subinterface of
Executor.
«interface»
java.util.concurrent.Executor
Executes the runnable task.
+execute(Runnable object): void
\
«interface»
java.util.concurrent.ExecutorService
+shutdown(): void
Shuts down the executor, but allows the tasks in the executor to
complete. Once shutdown, it cannot accept new tasks.
+shutdownNow(): List<Runnable>
Shuts down the executor immediately even though there are
unfinished threads in the pool. Returns a list of unfinished
tasks.
+isShutdown(): boolean
Returns true if the executor has been shutdown.
+isTerminated(): boolean
Returns true if all tasks in the pool are terminated.
22
OOP in Java : © W. Milner 2005 : Slide 22
Creating Executors
To create an Executor object, use the static methods in the
Executors class.
java.util.concurrent.Executors
+newFixedThreadPool(numberOfThreads: Creates a thread pool with a fixed number of threads executing
int): ExecutorService
concurrently. A thread may be reused to execute another task
after its current task is finished.
+newCachedThreadPool():
Creates a thread pool that creates new threads as needed, but
ExecutorService
will reuse previously constructed threads when they are
available.
import java.util.concurrent.*;
public class ExecutorDemo {
public static void main(String[] args) {
/* Create a fixed thread pool with maximum
three threads */
ExecutorService executor =
Executors.newFixedThreadPool(3);
// Submit runnable tasks to the executor
executor.execute(new PrintChar('a', 100));
executor.execute(new PrintChar('b', 100));
executor.execute(new PrintNum(100));
// Shut down the executor
executor.shutdown();
}
}
23
ExecutorDemo
OOP in Java : © W. Milner 2005 : Slide 23
Thread Synchronization
A shared resource may be corrupted if it is
accessed simultaneously by multiple threads. For
example, two unsynchronized threads accessing
the same bank account may cause conflict.
Step
balance
thread[i]
thread[j]
1
2
3
4
0
0
1
1
newBalance = bank.getBalance() + 1;
newBalance = bank.getBalance() + 1;
bank.setBalance(newBalance);
bank.setBalance(newBalance);
24
OOP in Java : © W. Milner 2005 : Slide 24
Example: Showing Resource Conflict
 Objective: Write a program that demonstrates the problem of resource
conflict. Suppose that you create and launch one hundred threads, each of
which adds a penny to an account. Assume that the account is initially
empty.
java.lang.Runnable
-char token
100
AddAPennyTask
+getToken
+setToken
+paintComponet
+mouseClicked
+run(): void
1
AccountWithoutSync
-bank: Account
-thread: Thread[]
1
1
Account
-balance: int
+getBalance(): int
+deposit(amount: int): void
+main(args: String[]): void
AccountWithoutSync
25
OOP in Java : © W. Milner 2005 : Slide 25
Race Condition
What, then, caused the error in the example? Here is a possible scenario:
Step
balance
Task 1
1
2
3
4
0
0
1
1
newBalance = balance + 1;
Task 2
newBalance = balance + 1;
balance = newBalance;
balance = newBalance;
);
The effect of this scenario is that Task 1 did nothing, because in
Step 4 Task 2 overrides Task 1's result. Obviously, the problem is
that Task 1 and Task 2 are accessing a common resource in a way
that causes conflict. This is a common problem known as a race
condition in multithreaded programs. A class is said to be threadsafe if an object of the class does not cause a race condition in the
presence of multiple threads. As demonstrated in the preceding
example, the Account class is not thread-safe.
26
OOP in Java : © W. Milner 2005 : Slide 26
The synchronized keyword
To avoid race conditions, more than one thread must be prevented from
simultaneously entering certain part of the program, known as critical region.
The critical region in the Listing 29.7 is the entire deposit method.You can
use the synchronized keyword to synchronize the method so that only one
thread can access the method at a time. There are several ways to correct the
problem in Listing 29.7, one approach is to make Account thread-safe by
adding the synchronized keyword in the deposit method in Line 45 as follows:
public synchronized void deposit(double amount)
27
OOP in Java : © W. Milner 2005 : Slide 27
Synchronizing Instance Methods and
Static Methods
A synchronized method acquires a lock before it executes. In the
case of an instance method, the lock is on the object for which the
method was invoked. In the case of a static method, the lock is on
the class. If one thread invokes a synchronized instance method
(respectively, static method) on an object, the lock of that object
(respectively, class) is acquired first, then the method is executed,
and finally the lock is released. Another thread invoking the same
method of that object (respectively, class) is blocked until the lock
is released.
28
OOP in Java : © W. Milner 2005 : Slide 28
Synchronizing Instance Methods and
Static Methods
With the deposit method synchronized, the preceding scenario cannot
happen. If Task 2 starts to enter the method, and Task 1 is already in the
method, Task 2 is blocked until Task 1 finishes the method.
Task 1
token
Acquire a-char
lock
on the object account
+getToken
-char token +setToken
+paintComponet
+getToken
Execute
the deposit method
+mouseClicked
+setToken
+paintComponet
-char
token
+mouseClicked
+getToken
Release the lock
+setToken
+paintComponet
-char token
+mouseClicked
+getToken
+setToken
+paintComponet
+mouseClicked
29
Task 2
-char token
+getToken
+setToken
+paintComponet
+mouseClicked
Wait to acquire the lock
-char token
+getToken
Acqurie a lock
+setToken
+paintComponet
-char
token
+mouseClicked
on the object account
+getToken
Execute the deposit method
+setToken
+paintComponet
-char
token
+mouseClicked
+getToken
Release the lock
+setToken
+paintComponet
OOP in Java : © W. Milner 2005 : Slide 29
Synchronizing Statements
Invoking a synchronized instance method of an object acquires a lock on the
object, and invoking a synchronized static method of a class acquires a lock on
the class. A synchronized statement can be used to acquire a lock on any
object, not just this object, when executing a block of the code in a method.
This block is referred to as a synchronized block. The general form of a
synchronized statement is as follows:
synchronized (expr) {
statements;
}
The expression expr must evaluate to an object reference. If the object is
already locked by another thread, the thread is blocked until the lock is
released. When a lock is obtained on the object, the statements in the
synchronized block are executed, and then the lock is released.
30
OOP in Java : © W. Milner 2005 : Slide 30
Synchronizing Statements vs.
Methods
Any synchronized instance method can be converted into a synchronized
statement. Suppose that the following is a synchronized instance method:
public synchronized void xMethod() {
// method body
}
This method is equivalent to
public void xMethod() {
synchronized (this) {
// method body
}
}
31
OOP in Java : © W. Milner 2005 : Slide 31
Synchronization Using Locks
A synchronized instance method implicitly acquires a lock on the instance
before it executes the method.
JDK 1.5 enables you to use locks explicitly. The new locking features are
flexible and give you more control for coordinating threads. A lock is an
instance of the Lock interface, which declares the methods for acquiring and
releasing locks, as shown in Figure 29.14. A lock may also use the
newCondition() method to create any number of Condition objects, which
can be used for thread communications.
«interface»
java.util.concurrent.locks.Lock
+lock(): void
Acquires the lock.
+unlock(): void
Releases the lock.
+newCondition(): Condition
Returns a new Condition instance that is bound to this
Lock instance.
java.util.concurrent.locks.ReentrantLock
+ReentrantLock()
Same as ReentrantLock(false).
+ReentrantLock(fair: boolean)
Creates a lock with the given fairness policy. When the
fairness is true, the longest-waiting thread will get the
lock. Otherwise, there is no particular access order.
32
OOP in Java : © W. Milner 2005 : Slide 32
Fairness Policy
ReentrantLock is a concrete implementation of Lock for creating
mutual exclusive locks.You can create a lock with the specified
fairness policy. True fairness policies guarantee the longest-wait
thread to obtain the lock first. False fairness policies grant a lock to
a waiting thread without any access order. Programs using fair
locks accessed by many threads may have poor overall performance
than those using the default setting, but have smaller variances in
times to obtain locks and guarantee lack of starvation.
33
OOP in Java : © W. Milner 2005 : Slide 33
Example: Using Locks
This example revises AccountWithoutSync.java in Listing 29.7 to
synchronize the account modification using explicit locks.
private static Lock lock = new
ReentrantLock(); // Create a lock
.
. // Critical Section
.
lock.lock(); // Acquire the lock
lock.unlock(); // Release the lock
AccountWithSyncUsingLock
34
OOP in Java : © W. Milner 2005 : Slide 34
Cooperation Among Threads
The conditions can be used to facilitate communications among threads. A
thread can specify what to do under a certain condition. Conditions are
objects created by invoking the newCondition() method on a Lock object.
Once a condition is created, you can use its await(), signal(), and signalAll()
methods for thread communications, as shown in Figure 29.15. The await()
method causes the current thread to wait until the condition is signaled. The
signal() method wakes up one waiting thread, and the signalAll() method
wakes all waiting threads.
«interface»
java.util.concurrent.Condition
+await(): void
Causes the current thread to wait until the condition is signaled.
+signal(): void
Wakes up one waiting thread.
+signalAll(): Condition
Wakes up all waiting threads.
35
OOP in Java : © W. Milner 2005 : Slide 35
Cooperation Among Threads
To synchronize the operations, use a lock with a condition: newDeposit
(i.e., new deposit added to the account). If the balance is less than the
amount to be withdrawn, the withdraw task will wait for the newDeposit
condition. When the deposit task adds money to the account, the task signals
the waiting withdraw task to try again. The interaction between the two
tasks is shown in Figure 29.16.
Deposit Task
Withdraw Task
-char token
-char token
lock.lock();
lock.lock();
+getToken
+setToken
-char token
+paintComponet
while
(balance < withdrawAmount)
+mouseClicked
+getToken
newDeposit.await();
+setToken
+paintComponet
+mouseClicked
+getToken
+setToken
-char
token
+paintComponet
balance += depositAmount
+mouseClicked
+getToken
+setToken
+paintComponet
-char
token
newDeposit.signalAll();
+mouseClicked
balance -= withdrawAmount
+getToken
+setToken
lock.unlock();
+paintComponet
+mouseClicked
-char token
-char token
lock.unlock();
+getToken
+setToken
36
OOP in Java : © W. Milner 2005 : Slide 36
Example: Thread Cooperation
Write a program that demonstrates thread cooperation. Suppose that you
create and launch two threads, one deposits to an account, and the other
withdraws from the same account. The second thread has to wait if the
amount to be withdrawn is more than the current balance in the account.
Whenever new fund is deposited to the account, the first thread notifies the
second thread to resume. If the amount is still not enough for a withdrawal,
the second thread has to continue to wait for more fund in the account.
Assume the initial balance is 0 and the amount to deposit and to withdraw is
randomly generated.
ThreadCooperation
37
OOP in Java : © W. Milner 2005 : Slide 37
Case Study: Producer/Consumer
Consider the classic Consumer/Producer example. Suppose you use a buffer to store
integers. The buffer size is limited. The buffer provides the method write(int) to add an int
value to the buffer and the method read() to read and delete an int value from the buffer. To
synchronize the operations, use a lock with two conditions: notEmpty (i.e., buffer is not
empty) and notFull (i.e., buffer is not full). When a task adds an int to the buffer, if the
buffer is full, the task will wait for the notFull condition. When a task deletes an int from the
buffer, if the buffer is empty, the task will wait for the notEmpty condition. The interaction
between the two tasks is shown in Figure 29.19.
Task for deleting an int
Task for adding an int
-char token
-char token
+getToken
while (count == CAPACITY)
+setToken
notFull.await();
+paintComponet
+mouseClicked
-char token
+getToken
while (count == 0)
+setToken
notEmpty.await();
+paintComponet
+mouseClicked
-char token
+getToken
Add an int to the buffer
+setToken
+paintComponet
-char token
+mouseClicked
+getToken
Delete an int to the buffer
+setToken
+paintComponet
-char token
+mouseClicked
+getToken
notEmpty.signal();
+getToken
notFull.signal();
+setToken
+paintComponet
-char token
41
+setToken
+paintComponet
-char token
OOP in Java : © W. Milner 2005 : Slide 41
Case Study: Producer/Consumer
Listing 29.10 presents the complete program. The program contains the
Buffer class (lines 43-89) and two tasks for repeatedly producing and
consuming numbers to and from the buffer (lines 15-41). The write(int)
method (line 58) adds an integer to the buffer. The read() method (line 75)
deletes and returns an integer from the buffer.
For simplicity, the buffer is implemented using a linked list (lines 48-49). Two
conditions notEmpty and notFull on the lock are created in lines 55-56. The
conditions are bound to a lock. A lock must be acquired before a condition
can be applied. If you use the wait() and notify() methods to rewrite this
example, you have to designate two objects as monitors.
ConsumerProducer
42
OOP in Java : © W. Milner 2005 : Slide 42
Deadlock
Sometimes two or more threads need to acquire the locks on several shared objects. This
could cause deadlock, in which each thread has the lock on one of the objects and is waiting
for the lock on the other object. Consider the scenario with two threads and two objects, as
shown in Figure 29.15 (32.25). Thread 1 acquired a lock on object1 and Thread 2 acquired a
lock on object2. Now Thread 1 is waiting for the lock on object2 and Thread 2 for the lock
on object1. The two threads wait for each other to release the in order to get the lock, and
neither can continue to run.
Step
1
2
3
4
5
6
Thread 2
Thread 1
synchronized (object1) {
synchronized (object2) {
// do something here
// do something here
synchronized (object2) {
synchronized (object1) {
// do something here
}
// do something here
}
}
}
Wait for Thread 2 to
release the lock on object2
Wait for Thread 1 to
release the lock on object1
48
OOP in Java : © W. Milner 2005 : Slide 48
Preventing Deadlock
Deadlock can be easily avoided by using a simple technique known as
resource ordering. With this technique, you assign an order on all the objects
whose locks must be acquired and ensure that each thread acquires the locks
in that order. For the example in Figure 29.15 (32.25) , suppose the objects
are ordered as object1 and object2. Using the resource ordering technique,
Thread 2 must acquire a lock on object1 first, then on object2. Once Thread
1 acquired a lock on object1, Thread 2 has to wait for a lock on object1. So
Thread 1 will be able to acquire a lock on object2 and no deadlock would
occur.
49
OOP in Java : © W. Milner 2005 : Slide 49
Thread States
A thread can be in one of five states:
New, Ready, Running, Blocked, or
Finished.
yield(), or
time out
Thread created
Running
run() returns
start()
New
Ready
Target
finished
run()
join()
interrupt()
Wait for target
to finish
Finished
sleep()
wait()
Wait for time
out
Time out
Blocked
Wait to be
notified
notify() or
notifyAll()
Interrupted()
50
OOP in Java : © W. Milner 2005 : Slide 50
TIP
Two things to remember when writing
Swing GUI programs,
 Time-consuming tasks should be run in
SwingWorker.
 Swing components should be accessed
from the event dispatch thread only.
57
OOP in Java : © W. Milner 2005 : Slide 57
JProgressBar
JProgressBar is a component that displays a value graphically within a bounded interval. A
progress bar is typically used to show the percentage of completion of a lengthy operation; it
comprises a rectangular bar that is "filled in" from left to right horizontally or from bottom
to top vertically as the operation is performed. It provides the user with feedback on the
progress of the operation. For example, when a file is being read, it alerts the user to the
progress of the operation, thereby keeping the user attentive.
JProgressBar is often implemented using a thread to monitor the completion status of other
threads. The progress bar can be displayed horizontally or vertically, as determined by its
orientation property. The minimum, value, and maximum properties determine the
minimum, current, and maximum length on the progress bar, as shown in Figure 9.20.
minimum
value
maximum
percentComplete = value / maximum
58
OOP in Java : © W. Milner 2005 : Slide 58
JProgressBar Methods
javax.swing.JComponent
javax.swing.JProgressBar
+JProgressBar()
Creates a horizontal progress bar with min 0 and max 100.
+JProgressBar(min: int, max: int)
Creates a horizontal progress bar with specified min and max.
+JProgressBar(orient: int)
Creates a progress bar with min 0 and max 100 and a specified orientation.
+JProgressBar(orient: int, min: int,
max: int)
Creates a progress bar with a specified orientation, min, and max.
+getMaximum(): int
Gets the maximum value. (default: 100)
+setMaximum(n: int): void
Sets a new maximum value.
+getMinimum(): int
Gets the minimum value. (default: 0)
+setMinimum(n: int): void
Sets a new minimum value.
+getOrientation(): int
Gets the orientation value. (default: HORIZONTAL)
+setOrientation(orient: int): void
Sets a new minimum value.
+getPercentComplete():double
Returns the percent complete for the progress bar. 0 <= a value <= 1.0.
+getValus(): int
Returns the progress bar's current value
+setValus(n: int): void
Sets the progress bar's current value.
+getString(): String
Returns the current value of the progress string.
+setString(s: String): void
Sets the value of the progress string.
+isStringPainted(): Boolean
Returns the value of the stringPainted property.
+setStringPainted(b: boolean): void Sets the value of the stringPainted property, which determines whether the
progress bar should render a progress percentage string. (default: false)
59
OOP in Java : © W. Milner 2005 : Slide 59
Example: JProgressBar Demo
Objective: Write a GUI application
that lets you copy files. A progress
bar is used to show the progress of
the copying operation.
CopyFile
60
OOP in Java : © W. Milner 2005 : Slide 60
Assignment 3
 *32.1 (Revise Listing 32.1) Rewrite Listing 32.1 to display the
output in a text area, as shown in Figure 32.31.
OOP in Java : © W. Milner 2005 : Slide 61
×

Report this document