Transcript Threads in Java

Concurrency
Synchronizing threads, thread
pools, etc.
Threads in Java
1
Creating threads
Class A extends Thread {
public void run() {
…
}
}
Class B implements Runnable {
public void run() {
…
}
}
A a = new A();
a.start();
B b = new B();
Tread t = new Thread(b);
t.start();
• A may not extend other
classes.
• B may extend another class.
• Decouples task submission
from thread scheduling, etc.
Threads in Java
2
Synchronizing threads
• Having threads in a programming
language is a nice feature, but threads
have to be controlled.
– If you have 2 or more threads with reference
to the same object, the threads might execute
methods on that object simultaneously.
• This must be controlled
Threads in Java
3
Race conditions and critical
sections
• Race condition
– 2 or more threads are reading or writing shared data
and the final result depends on the timing of the
thread scheduling.
– Race conditions are generally a bad thing!
• Critical section
– Part of a program (whole method or just a part of a
method) where race conditions might happen.
– To avoid race conditions
• We want to make sure that at most one thread executes the
critical section at any point in time.
• Threads must be synchronized.
Threads in Java
4
Locks on objects
• Every object has an associated lock.
• At most one thread can have the lock at any
point in time.
• A thread acquire the lock of the object when it
enters a synchronized block (i.e. critical section)
– If another thread holds the lock on the object the
entering thread has to wait (hopefully not forever).
• A thread releases the lock when it leaves the
synchronized block.
Threads in Java
5
Synchronization: Java syntax
public synchronized method() {
// critical section
}
• Often the whole method is a
critical section.
• You synchronize on the current
object, i.e. this.
Public method() {
…
synchronized(obj) {
// critical section
}
…
}
• Sometimes only part of a
method is a critical section.
• You synchronize on the object
mentioned.
• Less synchronization, means
more concurrency.
Threads in Java
6
Reentrant locks
• If a thread has a the lock on some object,
and then calls another synchronized
method,
– The thread does not have to wait for itself to
release the lock
– The lock is not released when it leaves the
latter method
• Since the thread had the lock before entering the
method.
Threads in Java
7
wait
• Entering a synchronized method a thread might
realize that it is not in a state to fulfill its task –
and it cannot simply return from the method
because the return value is not “ready”.
• The thread must wait
– Call wait()
• Method from class Object
• wait() really means this.wait()
• Releases the lock on the object
– Another thread can run, hopefully “fixing the state”
• Waits for another thread to call a notify() or notifyAll()
Threads in Java
8
notify() and notifyAll()
• obj.notify()
– Wakes up a single thread waiting on obj.
• The thread is randomly chosen
• obj.notifyAll()
– Wakes up all threads waiting on obj.
– Generally you want to use notifyAll() not
notify()
Threads in Java
9
Wait “Code pattern”
synchronized (obj) {
while (conditionDoesNotHold) {
obj.wait();
}
// perform action appropriate to the condition
}
• http://java.sun.com/books/tutorial/essential/threads/waitA
ndNotify.html
• wait() should always be called in a loop, since
obj.notifyAll() wakes up all thread waiting for the object.
• Only the first (quickest) should execute the synchronized
block. Other thread go back to wait.
Threads in Java
10
3 versions of wait
• wait()
– Waits indefinitely for notification
• hopefully not forever
• wait(long timeout)
– Waits for notification or until timeout milliseconds has
elapsed
• wait(long timeout, int nanos)
– Waits for notification or until timeout milliseconds +
nanos nanoseconds have elapsed.
Threads in Java
11
Collection framework
• Vector and HashTable
– Old collections
• From before the collections framework
– Methods are synchronized
• Synchronized wrappers
– Modern collections like List, Set, and Map
• From the collections framework
– Methods are not synchronized
– Methods can be synchronized using the synchronized wrappers
• Static methods in class Collections
–
–
–
–
Collection synchronizedCollection( Collection c )
List synchronizedList( List l )
Set synchronizedSet( Set s )
Map synchronizedMap( Map m )
Threads in Java
12
Thread pools
• Creating a new thread object takes relatively
much time
• Idea: Recycle thread objects.
–
–
–
–
Keep threads in a thread pool.
Request thread from pool.
Put used threads back into the pool.
java.util.concurrent offers more implementations of
this idea
• New in Java 5.0
• Example
– http://java.sun.com/j2se/1.5.0/docs/api/java/util/concu
rrent/ExecutorService.html
Threads in Java
13
Thread pool implementations
• The class Executors has 2 static methods
to create thread pools
– ExecutorService newFixedThreadPool(int
nThreads)
• Pool of a fixed size
– ExecutorService newCachedThreadPool()
• Creates new threads as needed.
• New threads are added to the pool, and recycled.
• ExecutorService has an execute method
– void execute(Runnable command)
Threads in Java
14
Callable vs. runnable interface
• Callable has 1
method
• Runnable has 1
method
– V call() throws
Exception
– Can return a value
– Can throw exceptions
• Can be executed
using an Executor
object
– void run()
– No return value
– No exceptions
• Can be executed
using an Executor
object
Threads in Java
15
Threads in Java Swing
• Java Swing has a single main thread
– Event-handling
– Painting visual components
– Called the event-dispatching-thread (EDT)
– Your “jobs” should be executed by the EDT
• To avoid deadlock
Threads in Java
16
Methods in javax.swing.Utilities
• The class javax.swing.Utilities has 2
interesting static methods
– SwingUtilities.invokeLater(Runnable r)
• Returns as soon as r is handed over to the EDT.
– Asynchronous
• Used for updating visual components.
• Java 1.3
– Calls java.awt.EventQueue.invokeLater(Runnable r)
– SwingUtilities.invokeAndWait(Runnable r)
• Returns when r has finished running
– Synchronous
Threads in Java
17
Starting a Swing based application
class MyFrame extends JFrame {
…
}
public static void main(String [] args) {
Runnable r = new Runnable() { // anonymous inner class
public void run() {
new MyFrame().setVisible();
}
}
EventQueue.invokeLater(r);
}
•
This is (almost) the code NetBeans 4.1 generates when you make a new
JFrame class!
Threads in Java
18
Use threads to improve
performance
• Move time-consuming tasks out of the
main thread
– GUI responds faster
– Create special threads for the time-consuming
tasks.
– Examples:
• Reading data from files, network connections,
databases, etc.
• Long running computations
Threads in Java
19
References
• Sun Microsystems The Java Tutorial, Threads
– http://java.sun.com/docs/books/tutorial/essential/threads/index.ht
ml
• Sun Microsystems Java 2 Platform Standard
Edition 5.0 API Specification: java.util.concurrent
– http://java.sun.com/j2se/1.5.0/docs/api/java/util/concurrent/packa
ge-summary.html
Threads in Java
20
More references
• Doug Lea Concurrent
Programming in Java 2nd
edition, Addison Wesley
2000
– Probably the most
important book on
concurrent programming in
Java – by the author who
wrote java.util.concurrent
• Oaks & Wong Java
Threads, O’Reilly 2004
• Niemeyer & Knudsen
Learning Java, 3rd edition,
O’Reilly 2005
– 9. Threads, page 249-297
Threads in Java
21