海量文库 文档专家
您现在的位置:首页 > 小学教育 > 小学英语小学英语


发布时间:2013-12-21 15:50:49  

《Java Programming》 Lesson 08:Multithreading
College of Computer Science Java Group http://eol.cqu.edu.cn/eol/jpk/c ourse/index.jsp?courseId=28 80


? ? ?

Thread Concept Creating Thread Control Thread


Synchronize threads


Threads Concept
Multiple threads on multiple CPUs
Thread 1 Thread 2 Thread 3

Multiple threads sharing a single CPU

Thread 1 Thread 2 Thread 3


Creating Tasks and Threads
java.lang.Runnable TaskClass
// Custom task class public class TaskClass implements Runnable { ... public TaskClass(...) { ... } // Implement the run method in Runnable public void run() { // Tell system how to run custom thread ... } ... } } // 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); // Start a thread thread.start(); ... } ...


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.


The Thread Class
? interface?
java.lang.Runnable java.lang.Thread
+Thread() +Thread(task: Runnable) +start(): void +isAlive(): boolean +setPriority(p: int): void +join(): void +sleep(millis: long): void +yield(): void +interrupt(): void Creates a default thread. Creates a thread for a specified task. Starts the thread that causes the run() method to be invoked by the JVM. Tests whether the thread is currently running. Sets priority p (ranging from 1 to 10) for this thread. Waits for this thread to finish. Puts the runnable object to sleep for a specified time in milliseconds. Causes this thread to temporarily pause and allow other threads to execute. Interrupts this thread.


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.

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.

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

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 token if (i == 50) thread4.join(); net to finish +mouseClicke } +getToken d } +getToken +setToken catch (InterruptedException ex) { +setToken +paintCompone } t +paintComponet } +mouseClicked Thread printA
-char token +getToken +setToken +paintCompo net +mouseClicke d

printA finished
-char token

The numbers after 50 are printed after thread printA is finished.

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.

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.


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



Example: Flashing Text




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.


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.



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 sec

onds 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.


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 1 2 3 4 balance 0 0 1 1 thread[i]
newBalance = bank.getBalance() + 1; newBalance = bank.getBalance() + 1; bank.setBalance(newBalance); bank.setBalance(newBalance);



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.
-char token
100 1 1 1

AddAPennyTask +getToken +setToken +paintComponet +mouseClicked +run(): void

-bank: Account -thread: Thread[]

-balance: int +getBalance(): int +deposit(amount: int): void

+main(args: String[]): void



Race Condition
What, then, caused the error in the example? Here is a possible scenario:
Step 1 2 3 4

balance 0 0 1 1

Task 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.

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)


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 (respectiv

ely, 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.

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
-char token Acquire a lock on the object account +getToken -char token +setToken +paintComponet +getToken +mouseClicked Execute the deposit method +setToken +paintComponet -char token +mouseClicked +getToken Release the lock +setToken +paintComponet -char token +mouseClicked +getToken +setToken +paintComponet +mouseClicked

Task 2
-char token +getToken +setToken +paintComponet +mouseClicked

Wait to acquire the lock
-char token +getToken Acqurie +setToken a lock +paintComponet -char token +mouseClicked

on the object account

+getToken Execute the deposit method +setToken +paintComponet -char token +mouseClicked +getToken Release the lock +setToken +paintComponet


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.

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 } }

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?
+lock(): void +unlock(): void +newCondition(): Condition Acquires the lock. Releases the lock. Returns a new Condition instance that is bound to this Lock instance


+ReentrantLock() +ReentrantLock(fair: boolean) Same as ReentrantLock(false). 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 or der.

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.


Example: Using Locks
This example revises AccountWithoutSync.java in Listing 29.7 to synchronize the account modification using explicit locks.




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?
+await(): void +signal(): void +signalAll(): Condition Causes the current thread to wait until the condition is signaled. Wakes up one waiting thread. Wakes up all waiting threads.


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.
Withdraw Task
-char token -char token

Deposit Task lock.lock();
+getToken +setToken -char token +paintComponet balance += depositAmount +mouseClicked +getToken +setToken +paintComponet -char token newDeposit.signalAll(); +mouseClicked +getToken +setToken lock.unlock(); +paintComponet +mouseClicked -char token

+getToken +setToken -char token +paintComponet while (balance +mouseClicked < withdrawAmount) +getToken newDeposit.await(); +setToken +paintComponet +mouseClicked

balance -= withdrawAmount
-char token

+getToken +setToken

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 Run

Java’s Built-in Monitors (Optional)
Locks and conditions are new in Java 5. Prior to Java 5, thread communications are programmed using object’s built-in monitors. Locks and conditions are more powerful and flexible than the built-in monitor. For this reason, this section can be completely ignored. However, if you work with legacy Java code, you may encounter the Java’s built-in monitor. A monitor is an object with mutual exclusion and synchronization capabilities. Only one thread can execute a method at a time in the monitor. A thread enters the monitor by acquiring a lock on the monitor and exits by releasing the lock. Any object can be a monitor. An object becomes a monitor once a thread locks it. Locking is implemented using the synchronized keyword on a method or a block. A thread must acquire a lock before executing a synchronized method or block. A thread can wait in a monitor if the condition is not right for it to continue executing in the monitor.

wait(), notify(), and notifyAll()
Use the wait(), notify(), and notifyAll() methods to facilitate communication among threads. The wait(), notify(), and notifyAll() methods must be called in a synchronized method or a synchronized block on the calling object of these methods. Otherwise, an IllegalMonitorStateException would occur. The wait() method lets the thread wait until some condition occurs. When it occurs, you can use the notify() or notifyAll() methods to notify the waiting threads to resume normal execution. The notifyAll() method wakes up all waiting threads, while notify() picks up only one thread from a waiting queue.

Example: Using Monitor
Task 1
synchronized (anObject) { try { // Wait for the condition to become true while (!condition) resume anObject.wait(); // Do something when condition is true } catch (InterruptedException ex) { ex.printStackTrace(); }

Task 2

synchronized (anObject) { // When condition becomes true anObject.notify(); or anObject.notifyAll(); ...






The wait(), notify(), and notifyAll() methods must be called in a synchronized method or a synchronized block on the receiving object of these methods. Otherwise, an IllegalMonitorStateException will occur. When wait() is invoked, it pauses the thread and simultaneously releases the lock on the object. When the thread is restarted after being notified, the lock is automatically reacquired. The wait(), notify(), and notifyAll() methods on an object are analogous to the await(), signal(), and signalAll() me

thods on a condition.

Case Study: Producer/Consumer (Optional)
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 adding an int
-char token +getToken(count == CAPACITY) while +setToken notFull.await(); +paintComponet +mouseClicked -char token +getToken to the buffer Add an int +setToken +paintComponet -char token +mouseClicked +getToken notEmpty.signal(); +setToken +paintComponet -char token

Task for deleting an int
-char token +getToken(count == 0) while +setToken notEmpty.await(); +paintComponet +mouseClicked -char token +getToken int to the buffer Delete an +setToken +paintComponet -char token +mouseClicked +getToken notFull.signal(); +setToken +paintComponet -char token


Case Study: Producer/Consumer (Optional)
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.



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. 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.


1 2 3 4 5 6

Thread 1
synchronized (object1) {

Thread 2

synchronized (object2) { // do something here // do something here synchronized (object2) { // do something here } } } synchronized (object1) { // do something here }

Wait for Thread 2 to release the lock on object2

Wait for Th

read 1 to release the lock on object1


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, 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.


Thread States
A thread can be in one of five states: New, Ready, Running, Blocked, or Finished.
yield(), or time out Thread created New start() Ready Target finished run() interrupt() join() sleep() wait() Finished Running run() returns

Wait for target to finish

Wait for time out Time out

Wait to be notified notify() or notifyAll()

Blocked Interrupted()


Homework: File Copyer with Progress indicator
Objective: Write a GUI application that lets you copy files. A progress bar is used to show the progress of the copying operation.



Homework: File Copyer with Progress indicator cont.
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 following figure.
minimum value maximum

percentComplete = value / maximum

Homework: File Copyer with Progress indicator cont.
javax.swing.JComponent javax.swing.JProgressBar
+JProgressBar() +JProgressBar(min: int, max: int) +JProgressBar(orient: int) +JProgressBar(orient: int, min: int, max: int) +getMaximum(): int +setMaximum(n: int): void +getMinimum(): int +setMinimum(n: int): void +getOrientation(): int +setOrientation(orient: int): void +getPercentComplete():double +getValus(): int +setValus(n: int): void +getString(): String +setString(s: String): void +isStringPainted(): Boolean Creates a horizontal progress bar with min 0 and max 100. Creates a horizontal progress bar with specified min and max. Creates a progress bar with min 0 and max 100 and a specified orientation. Creates a progress bar with a specified orientation, min, and

max. Gets the maximum value. (default: 100) Sets a new maximum value. Gets the minimum value. (default: 0) Sets a new minimum value. Gets the orientation value. (default: HORIZONTAL) Sets a new minimum value. Returns the percent complete for the progress bar. 0 <= a value <= 1.0. Returns the progress bar's current value Sets the progress bar's current value. Returns the current value of the progress string. Sets the value of the progress string. 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)


网站首页网站地图 站长统计
All rights reserved Powered by 海文库
copyright ©right 2010-2011。