Object-Oriented Design & Patterns

Cay S. Horstmann

Chapter 9

Concurrent Programming

Slide navigation: Forward with space bar, → arrow key, or PgDn. Backwards with ← or PgUp.

Chapter Topics

• Executing Tasks
• Thread Synchronization
• Animations

Threads

• Thread: program unit that is executed independently
• Multiple threads run simultaneously
• Virtual machine executes each thread
  • on separate processor if available
  • for short time slice if more threads than processors

Running Tasks

• Use ExecutorService to map tasks to threads

  ExecutorService service = Executors.newCachedThreadPool();
  

  or

  int processors = Runtime.getRuntime().availableProcessors();
  ExecutorService service = Executors.newFixedThreadPool(processors);

• Provide an object of a class that implements Runnable
• Runnable has one method

  void run()

• Place task action into run method
• Submit Runnable object to ExecutorService

  Runnable task = () -> { task instructions };
  service.execute(task)
  

Concurrent Tasks Example

• Run two tasks in parallel
• Each thread prints greetings

  public static Runnable greeter(String greeting, int repetitions)
  {
     return () ->
        {
           for (int i = 0; i < repetitions; i++)
              System.out.println(greeting);
        };
  }
  

• Obtain two Runnable instances

  Runnable r1 = greeter("Hello", 100);
  Runnable r2 = greeter("Goodbye", 100);

• Submit them to ExecutorService

  ExecutorService service = Executors.newCachedThreadPool();
  service.execute(r1);
  service.execute(r2);
  service.shutdown();

Concurrent Task Example

• ch09/greeting/ConcurrentGreetings.java
• Output

  Hello
  Hello
  Hello
  Goodbye
  ...
  Goodbye
  Goodbye
  Hello
  ...
  

Callables

• Use Callable<V> for a task that yields a result

  public interface Callable<V>
  {
     V call() throws Exception;
  }

• Execute Callable by submitting it to an ExecutorService

  Callable<V> task = . . .;
  Future<V> resultFuture = service.submit(task);

• You receive a Future<V>—an object that will yield a value in the future.

Futures

• get method blocks until value is available:

  V result = resultFuture.get()

• Normally not what you want—why use a separate thread if you are willing to wait in this thread?
• When breaking up a task into multiple subtasks to keep processor cores busy, makes sense to wait for all results.

  List<Callable<V>> tasks = . . .;
  List<Future<V>> resultFutures = service.invokeAll(tasks);
  for (Future<V> resultFuture : resultFutures)
  {
     V result = resultFuture.get();
     Incorporate result in the final result
  }

Application: How Many Long Words?

• ch09/longwords/LongWordCounter.java

Waiting For Completion of First Task

• When counting words, need all tasks to complete
• When finding a word, only need one task to complete

  try
  {
     V result = service.invokeAny(tasks);
     . . .
  }
  catch (ExecutionException ex)
  {
     // No task yielded a result
  } 

• The other tasks are interrupted

Interrupting Threads

• Thread terminates when run exits
• Sometimes necessary to terminate running thread
• Don't use deprecated stop method
• Interrupt thread by calling interrupt
• Calling t.interrupt() doesn't actually interrupt t; just sets a flag
• Interrupted thread must sense interruption and exit its run method
• Interrupted thread has chance to clean up

Sensing Interruptions

• Thread can occasionally call Thread.currentThread().isInterrupted()
• sleep, wait throw InterruptedException when thread interrupted
• . . . and then the interruption status is cleared!
• More robust: Sleep occasionally, catch InterruptedException and react to interruption
• Recommendation: Terminate run when sensing interruption

Sensing Interruptions

public class MyRunnable implements Runnable
{
   public void run()
   {
      try
      {
         while (...)
         {
            do work            
            Thread.sleep(...);
         }
      }
      catch (InterruptedException e)
      {
         // terminate thread
      }
   }
}

Thread Synchronization

• Use bounded queue from chapter 8
• Each producer thread inserts greetings into queue
• Each consumer thread removes greetings
• Two producers, one consumer
• Queue is large enough to hold all greetings

Producer Thread

for (int i = 0; i < repetitions; i++)
   queue.add(greeting);

Consumer Thread

int count1 = 0;
int count2 = 0;
for (int i = 0; i < repetitions; i++)
{
   String greeting = queue.remove();
   if (greeting1.equals(greeting)) count1++;
   else if (greeting2.equals(greeting)) count2++;
}
System.out.println(greeting1 + ": " + count1);
System.out.println(greeting2 + ": " + count2);

Main Method

public static void main(String[] args)
{
   int n = 1000;
   BoundedQueue<String> q = new BoundedQueue<>(2 * n);
   ExecutorService service = Executors.newCachedThreadPool();
   Runnable p1 = producer("Hello", q, n);
   Runnable p2 = producer("Goodbye", q, n);
   Runnable c = consumer("Hello", "Goodbye", q, 2 * n);
   service.execute(p1);
   service.execute(p2);
   service.execute(c);
   service.shutdown();
}

Expected and Actual Behavior

• Expected behavior:

  Hello: 1000
  Goodbye: 1000

• Actual behavior (numbers can vary with each run):

  Hello: 487
  Goodbye: 807

• Why?

Clicker Question

Why is the program corrupted?

• The producers weren't able to insert 2000 greetings into the queue because the queue filled up.
• The producers weren't able to insert 2000 greetings into the queue because the program terminated before it was done.
• The consumer wasn't able to remove 2000 greetings because the program terminated before it was done.
• Something else

Race Condition Scenario

• First thread calls add and executes elements[tail] = anObject;
• First thread at end of time slice
• Second thread calls add and executes elements[tail] = anObject; tail++;
• Second thread at end of time slice
• First thread executes tail++;

Race Condition Scenario

Locks

• Thread can acquire lock
• When another thread tries to acquire same lock, it blocks
• When first thread releases lock, other thread is unblocked and tries again
• Two kinds of locks
  • Objects of class implementing java.util.concurrent.Lock interface type, usually ReentrantLock
  • Locks that are built into every Java object

Reentrant Locks

aLock = new ReentrantLock();
. . .
aLock.lock();
try
{
   protected code
}
finally
{
   aLock.unlock();
}

Scenario with Locks

1. First thread calls add and acquires lock, then executes elements[tail] = anObject;
2. Second thread calls add and tries to acquire lock, but it is blocked
3. First thread executes tail++;
4. First thread completes add, releases lock
5. Second thread unblocked
6. Second thread acquires lock, starts executing protected code

Deadlocks

• Not enough to synchronize add, remove
• if (!queue.isFull()) queue.add(...); can still be interrupted
• Must move test inside add method

  public void add(E newValue)
  {
     queueLock.lock();
     try
     {
        while (queue is full)
           wait for more space
        . . .
     }
     finally { qeueLock.unlock(); }
  }
  

• Problem: nobody else can call remove

Avoiding Deadlocks

• Use condiiton object to manage "space available" condition

  private Lock queueLock = new ReentrantLock();
  private Condition spaceAvailableCondition
     = queueLock.newCondition();
  

• Call await when condition is not fulfilled:

  public void add(E newValue)
  {
     . . .
     while (size == elements.length)
        spaceAvailableCondition.await();
     . . .
  }

Avoiding Deadlocks

• Waiting thread is blocked
• Condition object manages set of threads that wait for the condition to change
• To unblock, another thread must call signalAll on the same condition object
• Call when state changes

  public E remove()
  {
     . . .
     E r = elements[head];
     . . .
     spaceAvailableCondition.signalAll(); // Unblock waiting threads
     return r;
  }
  

• All waiting threads removed from wait set, unblocked
• ch09/queue2/BoundedQueue.java

Visualizing Locks

• Object = phone booth
• Thread = person
• Locked object = closed booth
• Blocked thread = person waiting for booth to open

Visualizing Locks

Object Locks

• Each object has a lock
• Calling a synchronized method acquires lock of implicit parameter
• Leaving the synchronized method releases lock
• Nicer syntax than explicit Lock objects

  public class BoundedQueue<E>
  {
     public synchronized void add(E newValue) { . . . }
     public synchronized E remove() { . . . }
     . . .
  }

Object Locks

• Each implicit lock has one associated (anonymous) condition object
• Object.wait blocks current thread and adds it to wait set
• Object.notifyAll unblocks waiting threads

  public synchronized void add(E newValue)
     throws InterruptedException
  {
     while (size == elements.length) wait();
     elements[tail] = anObject;
     . . .
     notifyAll(); // notifies threads waiting to remove elements
  }

• ch09/queue3/BoundedQueue.java

Synchronized Blocks

• Can use object lock outside methods:

  synchronized (obj)
  {
     critical section      
  }

• Uses object lock to protect critical section
• Considered a feature:

  Map<String, Integer> map = . . .
  synchronized (map)
  {
     Integer value = map.get(key);
     if (value == null) map.put(key, 1);
     else map.put(key, value + 1);
  }
  

• Don't do this—easy to deadlock
• Use a ConcurrentHashMap instead

Threadsafe Queues in the Standard Library

• Don't use our BoundedQueue in production
• java.util.concurrent has professionally implemented threadsafe classes
• ArrayBlockingQueue (bounded), LinkedBlockingQueue (unbounded)
• Both implement BlockingQueue interface
• put, take block if full/empty
• add, remove throw exception if full/empty
• offer, poll return error code if full/empty (less useful in concurrent programs)

Example: Unique Long Words

• Each producer adds the long words found in a file
• Consumer puts them into set to filter out duplicates
• How do we know the producers are done?
• Each producer puts a “last bag” element on the queue
• Consumer counts them and finishes when all have arrived

Example: Unique Long Words

• longwords2/LongWordFinder.java

Algorithm Animation

• Use thread to make progress in algorithm
• Display algorithm state
• Example: Animate ch09/animation/Sorter.java
• Sleeps inside compare method
• Pass custom comparator

  Comparator<Double> comp = (d1, d2) ->
         {
            sleep
            return comparison result
         };
   

Algorithm Animation

• ch09/animation1/ArrayComponent.java
• ch09/animation1/AnimationTester.java

Pausing and Running the Animation

• Want to pause animation until "Run" or "Step" button is clicked
• Need to coordinate UI thread, animation thread
• Try to use built-in thread-safe construct in java.util.concurrent
• Trick: Use a blocking queue
• Button click adds string "Run" or "Step" to queue
• Animation thread calls take on the queue, blocks if no string inserted
• ch09/animation2/Sorter.java
• ch09/animation2/AnimationTester.java