• Multi-Tasking:
  • More than one application can be run "at the same time"
• Multi-Threading:
  • One application can run more than one method/function "at the same time"

• Multithreading Made "Easy":
  • When the code running in the different threads is independent
• Multithreading in General:
  • The threads interact, making the design and programming much more difficult

• A Dispatching Application:
  • We have "regular" dispatches every day
  • We must dispatch vehicles in real-time
• The Design:
  • 

javaexamples/threads/v1/Dispatcher.java

        import java.util.*;


/**
 * Used to dispatch vehicles in a fleet (e.g., emergency
 * response vehicles).
 *
 * @author  Prof. David Bernstein, James Madison University
 * @version 1.0
 */
public class Dispatcher
{
    protected int                    numberOfVehicles;
    protected LinkedList<Integer>    availableVehicles;
    

    /**
     * Construct a new Dispatcher
     *
     * @param n   The number of vehicles in the fleet
     */
    public Dispatcher(int n)
    {
       int     i;

       numberOfVehicles = n;
       availableVehicles = new LinkedList<Integer>();

       for (i=0; i < n; i++)
       {
          makeVehicleAvailable(i);
       }
    }

    /**
     * Dispatch an available vehicle
     *
     * @param  task  The task to be handled
     * @return       true if a vehicle was dispatched
     */
    public boolean dispatch(String task)
    {
       boolean  ok;
       int      vehicle;
       Integer  v;

       ok = false;
       if (availableVehicles.size() > 0)
       {
          v = availableVehicles.removeFirst();
          vehicle = v.intValue();
          sendMessage(vehicle, task);
          ok = true;
       }
       else
       {
          ok = false;          
       }
       

       return ok;
    }

    /**
     * Makes a vehicle available for future dispatching
     *
     * @param vehicle  The number of the vehicle
     */
    public void makeVehicleAvailable(int vehicle)
    {
       availableVehicles.addLast(new Integer(vehicle));
    }

    /**
     * Sends a message to a vehicle
     *
     * @param vehicle  The number of the vehicle
     * @param message  The message to send
     */
    private void sendMessage(int vehicle, String message)
    {

       // This method would normally transmit the message 
       // to the vehicle.  For simplicity, it now writes it 
       // to the screen instead.

       System.out.println(vehicle+"\t"+message+"\n");
       System.out.flush();       
    }
}
        

javaexamples/threads/v1/AbstractDispatchHandler.java

        import java.io.*;
import java.util.*;

/**
 * An abstract dispatch handler.
 *
 * @author  Prof. David Bernstein, James Madison University
 * @version 1.0
 */
public abstract class AbstractDispatchHandler
{
    protected BufferedReader   in;    
    protected Dispatcher       dispatcher;

    /**
     * Construct a new DailyDispatchHandler
     *
     * @param d   The Dispatcher to use
     * @param f   The name of the dispatch file
     */
    public AbstractDispatchHandler(Dispatcher d, BufferedReader in) 
    {
       dispatcher = d;
       this.in    = in;
    }

    /**
     * Process an individual dispatch.
     *
     * @param line  The dispatch
     */
    protected abstract void processDispatch(String line);
    

    /**
     * Process the daily dispatches
     *
     * Note: This method will continue to execute until 
     * all vehicles have been dispatched.  This could take
     * all day.  The application will not be able to
     * do anything else while this method is executing.
     */
    public void processDispatches()
    {
       String            line;

       do
       {
           try
           {
               line = in.readLine();               
               if (line != null) processDispatch(line);
           }
           catch (IOException ioe)
           {
               line = "";               
               System.err.println("Unable to read a dispatch");
           }
       } while (line != null);       
    }

    /**
     * Start this DailyDispatchHandler
     *
     * Specifically, process the daily dispatches
     */
    public void start()
    {
        processDispatches();

        try 
        {
            in.close();
        }
        catch (IOException ioeClose)
        {
            System.err.println("Unable to close dispatches");
        }
    }
}
        

javaexamples/threads/v1/DailyDispatchHandler.java

        import java.io.*;
import java.util.*;

/**
 * A class that reads in the daily list of dispatching 
 * tasks from a file and hands them off to a Dispatcher
 *
 * Note: While this class' processDispatches()
 * method is executing, the application
 * will not be able to do anything else.
 *
 * @author  Prof. David Bernstein, James Madison University
 * @version 1.0
 */
public class DailyDispatchHandler extends AbstractDispatchHandler
{
    private long             currentTime, lastTime;

    /**
     * Construct a new DailyDispatchHandler
     *
     * @param d   The Dispatcher to use
     * @param f   The name of the dispatch file
     */
    public DailyDispatchHandler(Dispatcher d, String f) throws IOException
    {
        super(d, new BufferedReader(new FileReader(f)));
        lastTime = System.currentTimeMillis();
    }

    /**
     * Process an individual dispatch (required by 
     * AbstractDispatchHandler).
     *
     * @param line   The dispatch
     */
    public void processDispatch(String line)
    {
       int               wait;
       String            message;
       StringTokenizer   st;

       st = new StringTokenizer(line,"\t");
       wait = Integer.parseInt(st.nextToken());
       message = st.nextToken();
       
       // Wait until the appropriate time before dispatching
       while (System.currentTimeMillis()-lastTime < wait)
       {
           // Do nothing
       }
       
       dispatcher.dispatch(message);
       lastTime = System.currentTimeMillis();
    }
}
        

javaexamples/threads/v1/RealTimeDispatchHandler.java

        import java.io.*;
import java.util.*;

/**
 * A class that reads in dispatching tasks from the console and hands
 * them off to a Dispatcher
 *
 * @author  Prof. David Bernstein, James Madison University
 * @version 1.0
 */
public class RealTimeDispatchHandler extends AbstractDispatchHandler
{
    /**
     * Construct a new DailyDispatchHandler
     *
     * @param d   The Dispatcher to use
     */
    public RealTimeDispatchHandler(Dispatcher d) throws IOException
    {
        super(d, new BufferedReader(new InputStreamReader(System.in)));
    }

    /**
     * Process an individual dispatch (required by 
     * AbstractDispatchHandler).
     *
     * @param line   The dispatch
     */
    public void processDispatch(String line)
    {
        dispatcher.dispatch(line);
    }
}
        

javaexamples/threads/v1/Driver.java

        import java.io.*;
import java.util.Date;

/**
 * The driver for an example that motivates the need for 
 * multi-threaded applications
 *
 * @author  Prof. David Bernstein, James Madison University
 * @version 1.0
 */
public class Driver
{
    /**
     * The entry point of the application
     *
     * @param args   The command line arguments
     */
    public static void main(String[] args) throws IOException
    {
       DailyDispatchHandler     daily;
       Dispatcher               dispatcher;
       RealTimeDispatchHandler  rt;
       String                   userInput;


       dispatcher = new Dispatcher(50);
        

       try 
       {
           daily = new DailyDispatchHandler(dispatcher, "dispatches.txt");
           daily.start();
       }
       catch (IOException ioe)
       {
           System.err.println("Unable to open daily dispatches.");
       }
       
        
       try
       {
           rt = new RealTimeDispatchHandler(dispatcher);
           rt.start();
       }
       catch (IOException ioe)
       {
           System.err.println("Unable to read from the console.");
       }
    }
}
        

• The Problem:
  • The RealTimeDispatchHandler does not start working until the DailyDispatchHandler has completed its job
  • In other words, the while loop in the processDispatches() method maintains control of the CPU until all of the daily dispatches have been completed
• What We Need:
  • A way for multiple objects to use the Dispatcher "at the same time"

javaexamples/threads/v2/AbstractDispatchHandler.java

        import java.io.*;
import java.util.*;

/**
 * An abstract dispatch handler.
 *
 * Note: This version starts a new thread of execution
 * to process the daily dispatches.
 *
 * @author  Prof. David Bernstein, James Madison University
 * @version 2.0
 */
public abstract class AbstractDispatchHandler implements Runnable
{
    protected BufferedReader   in;    
    protected Dispatcher       dispatcher;
    protected Thread           controlThread;    

    /**
     * Construct a new DailyDispatchHandler
     *
     * @param d   The Dispatcher to use
     * @param f   The name of the dispatch file
     */
    public AbstractDispatchHandler(Dispatcher d, BufferedReader in) 
    {
       dispatcher = d;
       this.in    = in;
    }

    /**
     * Process an individual dispatch.
     *
     * @param line  The dispatch
     */
    protected abstract void processDispatch(String line);
    

    /**
     * Process the daily dispatches.
     *
     * Note: This method will continue to execute until 
     * all vehicles have been dispatched.  This could take
     * all day.  The application will not be able to
     * do anything else while this method is executing.
     */
    public void processDispatches()
    {
       String            line;

       do
       {
           try
           {
               line = in.readLine();               
               if (line != null) processDispatch(line);
           }
           catch (IOException ioe)
           {
               line = "";               
               System.err.println("Unable to read a dispatch");
           }
       } while (line != null);       
    }

    /**
     * Start this AbstractDispatchHandler.
     *
     * Specifically, start a new thread of execution and process
     * the dispatches in this thread.
     */
    public void start()
    {
       if (controlThread == null)
       {
          controlThread = new Thread(this);
          controlThread.start();        
       }
    }

    /**
     * The code that runs in this AbstractDispatchHandler
     * objects thread of execution (required by Runnable).
     */
    public void run()
    {
        processDispatches();

        try 
        {
            in.close();
        }
        catch (IOException ioeClose)
        {
            System.err.println("Unable to close dispatches");
        }
    }
}
        

• Some Important Observations:
  • The Dispatcher now has shared mutable state
• The Implication:
  • We must coordinate the threads
• Before Exploring Coordination:
  • We should consider some other issues

• An Observation:
  • The DailyDispatchHandler uses a tight loop that wastes processor resources
• A Fix:
  • Have the thread sleep

javaexamples/threads/v3/DailyDispatchHandler.java

        import java.io.*;
import java.util.*;

/**
 * A class that reads in the daily list of dispatching 
 * tasks from a file and hands them off to a Dispatcher.
 *
 * Note: This version sleeps between dispatches rather than
 * running in a tight loop.
 *
 * @author  Prof. David Bernstein, James Madison University
 * @version 3.0
 */
public class DailyDispatchHandler extends AbstractDispatchHandler
{
    /**
     * Construct a new DailyDispatchHandler
     *
     * @param d   The Dispatcher to use
     * @param f   The name of the dispatch file
     */
    public DailyDispatchHandler(Dispatcher d, String f) throws IOException
    {
        super(d, new BufferedReader(new FileReader(f)));
    }

    /**
     * Process an individual dispatch (required by 
     * AbstractDispatchHandler).
     *
     * @param line   The dispatch
     */
    public void processDispatch(String line)
    {
       int               wait;
       String            message;
       StringTokenizer   st;

       st = new StringTokenizer(line,"\t");
       wait = Integer.parseInt(st.nextToken());
       message = st.nextToken();

       try
       {
           // Sleep the appropriate amount of time 
           // before dispatching the vehicle.  Other
           // threads can execute while this one
           // is sleeping.
           //
           controlThread.sleep(wait);
           
           dispatcher.dispatch(message);
       }
       catch (InterruptedException ie)
       {
           // Don't dispatch
       }
    }
}
        

• The interrupt() Method:
  • Used to ask a thread to stop what it is currently doing (by setting its interrupt status to true
• Writing Cancellable Methods:
  • Periodically check the interrupt status using the isInterrupted() method of the controlling Thread object

• Some Remaining Problems:
  • The DailyDispatchHandler and RealTimeDispatcher run until EOS
• A Solution:
  • Add a boolean attribute called keepRunning and change the do-while loop from do{...}while (line != null); to do{...}while (keepRunning && (line != null));
  • Add a stop() method that assigns false to keepRunning

• An Observation:
  • One thread "stores" values in keepRunning (i.e., the thread that stop() executes in) and another "loads" values from it (i.e., the dispatch handler's thread)
• A Speculation:
  • This doesn't cause a problem since "store" and "load" must be atomic
• In Fact:
  • Java does not ensure that changes to attributes that are made in one thread will propogate to other threads in the way you would expect (e.g., because of processor-specific caching and the re-ordering of operations)

• The volatile Modifier:
  • Indicates to the compiler and JVM that the variable is shared
• The Impact:
  • A read of a volatible attribute always returns the most recent write by any thread
• A Caution:
  • volatile reference types only provide this guarantee for the referenec itself (e.g., not the elemnts of an array or the attributes of an object)

javaexamples/threads/v4/AbstractDispatchHandler.java

        import java.io.*;
import java.util.*;

/**
 * An abstract dispatch handler.
 *
 * Note: This version allows the thread of execution
 * to be stopped (after the blocking I/O operation completes.)
 *
 * @author  Prof. David Bernstein, James Madison University
 * @version 4.0
 */
public abstract class AbstractDispatchHandler implements Runnable
{
    protected volatile boolean keepRunning;    
    protected BufferedReader   in;    
    protected Dispatcher       dispatcher;
    protected Thread           controlThread;    

    /**
     * Construct a new DailyDispatchHandler
     *
     * @param d   The Dispatcher to use
     * @param f   The name of the dispatch file
     */
    public AbstractDispatchHandler(Dispatcher d, BufferedReader in) 
    {
       dispatcher = d;
       this.in    = in;
    }

    /**
     * Process an individual dispatch.
     *
     * @param line  The dispatch
     */
    protected abstract void processDispatch(String line);
    

    /**
     * Process the daily dispatches.
     *
     * Note: This method will continue to execute until 
     * all vehicles have been dispatched.  This could take
     * all day.  The application will not be able to
     * do anything else while this method is executing.
     */
    public void processDispatches()
    {
       String            line;

       do
       {
           try
           {
               line = in.readLine();               
               if (line != null) processDispatch(line);
           }
           catch (IOException ioe)
           {
               line = "";               
               System.err.println("Unable to read a dispatch");
           }
       } while (keepRunning && (line != null));       
    }

    /**
     * Start this AbstractDispatchHandler.
     *
     * Specifically, start a new thread of execution and process
     * the dispatches in this thread.
     */
    public void start()
    {
       if (controlThread == null)
       {
          controlThread = new Thread(this);
          keepRunning   = true;          
          controlThread.start();        
       }
    }

    /**
     * Stop this AbstractDispatchHandler.
     */
    public void stop()
    {
        keepRunning = false;   

        // Interrupt the thread of execution in case
        // it is in a wait state.
        controlThread.interrupt();
    }
    

    /**
     * The code that runs in this AbstractDispatchHandler
     * objects thread of execution (required by Runnable).
     */
    public void run()
    {
        processDispatches();

        try 
        {
            in.close();
        }
        catch (IOException ioeClose)
        {
            System.err.println("Unable to close dispatches");
        }
    }
}
        

• An Observation:
  • The Dispatcher has shared mutable state
• The Implication:
  • We need to take steps to ensure that the code is correct

javaexamples/threads/v1/Dispatcher.java (Fragment: dispatch)

            /**
     * Dispatch an available vehicle
     *
     * @param  task  The task to be handled
     * @return       true if a vehicle was dispatched
     */
    public boolean dispatch(String task)
    {
       boolean  ok;
       int      vehicle;
       Integer  v;

       ok = false;
       if (availableVehicles.size() > 0)
       {
          v = availableVehicles.removeFirst();
          vehicle = v.intValue();
          sendMessage(vehicle, task);
          ok = true;
       }
       else
       {
          ok = false;          
       }
       

       return ok;
    }
        

• The Situation:
  • One vehicle in the queue
  • The first thread executes all of the code up to and including the evaluation of (availableVehicles.size() > 0) and then runs out of time
  • The seconds thread executes all of the code in this method before it runs out of time
• The Problem:
  • When the first thread starts executing again, it will proceed as if it had never been off the CPU and will attempt to get a vehicle from the queue (which is empty)

• Defined:
  • Code that causes the correctness of a computation to depend on the relative timing of different threads
• This Example:
  • A check-then-act condition
• Other Kinds:
  • read-modify-write conditions

• A Simpler Example:

  •       public int getNextIndex()
          {
    	return ++index;
          }
        

• The Problem:
  • This method can return the same value to two threads since the increment operator is not atomic - it loads the value (read), increments the value (modify), and stores the value (write)

javaexamples/threads/NonatomicInteger.java

        /**
 * An encapsulation of a MutableInteger that can be used to demonstrate
 * various problems that arise when using shared mutable state.
 *
 * @author  Prof. David Bernstein, James Madison University
 * @version 1.0
 */
public class NonatomicInteger implements MutableInteger
{
    private int    value;
 
    /**
     * Explicit Value Constructor.
     *
     * @param initial   The initial value
     */
    public NonatomicInteger(int initial)
    {
        set(initial);
    }
    
    /**
     * Get the current value of this MutableInteger.
     *
     * @return  The current value
     */
    public int get()
    {
        return value;
    }
   
    /**
     * Increment (and return) the value of this MutableInteger.
     *
     * @return  The current value (i.e., after it is incremented)
     */
    public int incrementAndGet()
    {
        ++value;
        return value;
    }
    
    /**
     * Set the value of this MutableInteger.
     *
     * @param value  The new value
     */
    public void set(int value)
    {
        this.value = value;
    }
}
        

javaexamples/threads/Counter.java

        /**
 * An implementation of Runnable that increases a MutableInteger.
 * It can be used to illustrate problems that can arise when using shared 
 * mutable state.
 *
 * @author  Prof. David Bernstein, James Madison University
 * @version 1.0
 */
public class Counter implements Runnable
{
    private int                iterations;
    private MutableInteger     mutable;
    
    /**
     * Explicit Value Constructor.
     *
     * @param mutable    The MutableInteger to use
     * @param iterations The number of times to increment the MutableInteger
     */
    public Counter(MutableInteger mutable, int iterations)
    {
        this.mutable    = mutable;        
        this.iterations = iterations;        
    }
    
    /**
     * The code to run in the thread of execution.
     */
    public void run()
    {
        for (int i=0; i<iterations; i++)
        {
            mutable.incrementAndGet();
        }
        System.out.printf("Value: %d\n", mutable.get());
    }
}
        

javaexamples/threads/CounterDriver.java

        /**
 * An application that illustrates some of the problems that can arise
 * when using shared mutable state, and how synchronization can
 * prevent them.
 *
 * If the application is run with no command line arguments it will
 * use a NonatomicInteger. If any command line arguments are provided
 * it will use a SynchronizedInteger.
 *
 * @author  Prof. David Bernstein, James Madison University
 * @version 1.0
 */
public class CounterDriver
{
    private static final int ITERATIONS = 1000000;    
    private static final int THREADS    = 5;    

    /**
     * The entry point of the application.
     *
     * @param args  The command line arguments
     */
    public static void main(String[] args)
    {
        MutableInteger       mutable;

        if ((args != null) && (args.length > 0))
            mutable = new SynchronizedInteger(0);
        else
            mutable = new NonatomicInteger(0);
        
        for (int i=0; i<THREADS; i++)
        {
            Thread thread = new Thread(new Counter(mutable, ITERATIONS));
            thread.start();
        }
    }
    
}
        

• Monitors (a.k.a. Implicit Locks):
  • Every object (and class) has a "concurrency protection" object called a monitor
  • A thread of execution can only enter a synchronized method or block if it can acquire the relevant monitor
  • When a thread exits a synchronized method it releases the monitor
• How This Provides Protection:
  • Only one thread can acquire a monitor at a time
  • Other threads block until they can acquire the relevant monitor
• A Detail:
  • One thread can acquire the same monitor multiple times (a counter is used), making it re-entrant

• synchronized Methods:
  • The method is declared synchronized
  • The "owner's" monitor is used
• synchronized Blocks:
  • The block is declared to be synchronized
  • The declaration explicitly includes the Object whose monitor should be used

javaexamples/threads/SynchronizedInteger.java

        /**
 * An encapsulation of a MutableInteger that can be used to
 * demonstrate how synchronization can avoid the problems that arise
 * when using shared mutable state.
 *
 * @author  Prof. David Bernstein, James Madison University
 * @version 1.0
 */
public class SynchronizedInteger implements MutableInteger
{
    private int    value;
 
    /**
     * Explicit Value Constructor.
     *
     * @param initial   The initial value
     */
    public SynchronizedInteger(int initial)
    {
        set(initial);
    }
    
    /**
     * Get the current value of this MutableInteger.
     *
     * @return  The current value
     */
    public synchronized int get()
    {
        return value;
    }
   
    /**
     * Increment (and return) the value of this MutableInteger.
     *
     * @return  The current value (i.e., after it is incremented)
     */
    public synchronized int incrementAndGet()
    {
        ++value;
        return value;
    }
    
    /**
     * Set the value of this MutableInteger.
     *
     * @param value  The new value
     */
    public synchronized void set(int value)
    {
        this.value = value;
    }
}
        

javaexamples/threads/v5a/Dispatcher.java (Fragment: dispatch)

            /**
     * Dispatch an available vehicle
     *
     * @param  task  The task to be handled
     * @return       true if a vehicle was dispatched
     */
    public synchronized boolean dispatch(String task)
    {
       boolean  ok;
       int      vehicle;
       Integer  v;

       ok = false;
       if (availableVehicles.size() > 0)
       {
          v = availableVehicles.removeFirst();
          vehicle = v.intValue();
          sendMessage(vehicle, task);
          ok = true;
       }
       else
       {
          ok = false;          
       }
       return ok;
    }
        

• The Fault:
  • Both the dispatch() method and the makeVehicleAvailable() method change the queue
  • So, one thread can be removing vehicles from the queue and another thread can be adding vehicles to the queue
• The Fix:
  • Synchronize makeVehicleAvailable()

javaexamples/threads/v5a/Dispatcher.java (Fragment: makeVehicleAvailable)

        
    /**
     * Makes a vehicle available for future dispatching
     *
     * @param vehicle  The number of the vehicle
     */
    public synchronized void makeVehicleAvailable(int vehicle)
    {
       availableVehicles.addLast(new Integer(vehicle));
    }
        

• Defined:
  • A state in which an application/algorithm is unable to make progress
• Types:
  • Deadlock - two or more threads are waiting on a condition that can't be satisfied
  • Livelock - a thread can't make progress because it repeatedly attempts an operation that fails (e.g., "you first", "no, you first")

• A Seemingly Small Change:
  • Suppose the dispatch() method is modified so that, instead of returning false if no vehicles are available it loops until one is available
• A Deadlock Situation:
  • No vehicles are available and one thread acquries the monitor by executing dispatch()
• Why this is a Deadlock:
  • No other thread can acquire the monitor and execute makeVehicleAvailable()

• One Possible Fix:
  • Have the thread executing the dispatch() method enter the waiting state if no vehicles are available
• Why It Works:
  • The thread gives up the monitor so makeVehicleAvailable() can be executed in another thread
• To Remember:
  • The thread that executes makeVehicleAvailable() must notify the waiting threads

javaexamples/threads/v6a/Dispatcher.java

        import java.util.*;


/**
 * Used to dispatch vehicles in a fleet (e.g., emergency
 * response vehicles).
 *
 * In this version, dispatch() does not return true/false, it waits until
 * a vehicle is available.
 *
 * @author  Prof. David Bernstein, James Madison University
 * @version 6.0a
 */
public class Dispatcher
{
    protected int                    numberOfVehicles;
    protected LinkedList<Integer>    availableVehicles;

    private   Object                 lock;    

    /**
     * Construct a new Dispatcher
     *
     * @param n   The number of vehicles in the fleet
     */
    public Dispatcher(int n)
    {
       int     i;

       lock = new Object();

       numberOfVehicles = n;
       availableVehicles = new LinkedList<Integer>();

       for (i=0; i < n; i++)
       {
          makeVehicleAvailable(i);
       }
    }

    /**
     * Dispatch an available vehicle.
     *
     * @param  task  The task to be handled
     * @return       true (to be consistent with earlier versions)
     */
    public boolean dispatch(String task)
    {
        boolean ok;
        
        synchronized(lock)
        {
            do
            {
                ok = attemptToDispatch(task);

                if (!ok)
                {
                    try
                    {
                        lock.wait();                
                    }
                    catch (InterruptedException ie)
                    {
                        // Ignore
                    }
            } 
            while (ok == false);
        }
        
        return true;        
    }

    /**
     * Attempt to dispatch a vehicle.
     *
     * @param task  The task.
     * @return      true if the dispatch was successful; false otherwise
     */ 
    private boolean attemptToDispatch(String task)
    {
        boolean  ok;
        int      vehicle;
        Integer  v;

        ok = false;
        if (availableVehicles.size() > 0)
        {
            v = availableVehicles.removeFirst();
            vehicle = v.intValue();
            sendMessage(vehicle, task);
            ok = true;            
        }

       return ok;
    }

    /**
     * Makes a vehicle available for future dispatching
     *
     * @param vehicle  The number of the vehicle
     */
    public void makeVehicleAvailable(int vehicle)
    {
        synchronized(lock)
        {
            availableVehicles.addLast(new Integer(vehicle));
            lock.notifyAll();
        }
    }

    /**
     * Sends a message to a vehicle
     *
     * @param vehicle  The number of the vehicle
     * @param message  The message to send
     */
    private void sendMessage(int vehicle, String message)
    {

       // This method would normally transmit the message 
       // to the vehicle.  For simplicity, it now writes it 
       // to the screen instead.

       System.out.println(vehicle+"\t"+message+"\n");
       System.out.flush();       
    }
}
        

• Memory Consistency Errors:
  • Occur when different threads have inconsistent views of what should be the same data (e.g., as with keepRunning before it was declared to be volatile)
• The Happens-Before Relationship:
  • A guarantee that memory writes by one specific statement are visible to another specific statement

• Some Actions that Create Happens-Before Relationships:
  • Each action in a thread happens-before every action in that thread that comes later in the program's order
  • A synchronized block or method exit happens-before every subsequent synchronized block or method entry
  • A write to a volatile attribute happens-before every subsequent read of that same attribute
  • A call to start() on a thread happens-before any action in the started thread
  • All actions in a thread happen-before any other thread successfully returns from a join() on that thread
• Transitivity?
  • The happens-before relationship is transitive

• Coordination:
  • Alternatives to Monitors
• Thread-Aware Objects:
  • Synchronized Collections
  • Concurrent Collections
  • Atomic Variables
• Pools:
  • Executors and Thread Pools
  • Fork/Join Pools

• Thread Confinement:
  • Stack Confinement
  • ThreadLocal
• Building on Thread-Safe Classes:
  • Composing Thread-Safe Objects
  • Adding Functionality to Thread-Safe Classes