1. Synchronizing threads, thread pools, etc.
Concurrency
Synchronizing threads, thread pools, etc.
Threads in Java

2. Creating threads Class A extends Thread { public void run() { … }
A a = new A();
a.start();
A may not extend other classes.
Class B implements Runnable {
public void run() { … }
B b = new B();
Tread t = new Thread(b);
t.start();
B may extend another class.
Decouples task submission from thread scheduling, etc.
Threads in Java

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

4. Race conditions and critical sections
2 or more threads are reading or writing share 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

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

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

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

8. 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() / notifyAll()
Threads in Java

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

10. Wait “Code pattern” synchronized (obj) {
while (conditionDoesNotHold) {
obj.wait(); }
// perform action appropriate to the condition
wait() should always be called in a loop, since obj.notifyAll() wakes up all thread waiting for the obj. Only the first (quickest) should execute the synchronized block. Other thread go back to wait.
Threads in Java

11. 3 versions of wait wait() wait(long timeout)
Waits indefinitely for notification
hopefully not forever
wait(long timeout)
Waits for notification or until timeout miliseconds has elapsed
wait(long timeout, int nanos)
Waits for notification or until timeout miliseconds + nanos nanoseconds have elapsed.
Threads in Java

12. Collection framework Vector, HashTable Synchronized wrappers
Old collections
From before the collections framework
Methods are synchonized
Synchronized wrappers
Modern collections
From the collections framework
Methods are not synchronized
Methods can be synchronized using the synchronized wrappers
Static methods in class Collections
Colletion synchronizedCollection(Collection c)
List synchronizedList(List l)
Set synchronizedSet(Set s)
Map synchronizedMap(Map m)
Threads in Java

13. 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 thread back in the pool.
Java.util.concurrent offers more implementations of this idea
New in Java 5.0
Example
Threads in Java

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

15. Callable vs. runnable interface
Callable has 1 method
V call() throws Exception
Can return a value
Can throw exceptions
Can be executed using an Executor object
Runnable has 1 method
Void run()
No return value
No exceptions
Can be executed using an Executor object
Threads in Java

16. Threads in Java Swing Java Swing has a single main thread
Event-handling
Painting visual components
Called the event-dispatching-thread (EDT)
Your threads should be executed by the EDT
To avoid deadlock
Threads in Java

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

18. Starting a Swing based application
class MyFrame extends JFrame { … }
public static void main(String [] args) {
Runnable r = new Runnable() {
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

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

20. References Sun Microsystems The Java Tutorial, Threads
Sun Microsystems Java 2 Platform Standard Edition 5.0 API Specification: java.util.concurrent
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
Threads in Java