• Using Multiple Threads:
  • Allows a program to do multiple things "at the same time"
• A Common "Mistake":
  • Coupling the task to be performed with how the task will be executed
• A Common Defect Leading to this "Mistake":
  • A performance defect that is corrected by adding a thread

• Defined:
  • Code that takes too much time to execute
• Common Types:
  • Complicated code
  • Code that blocks/sleeps/waits

• An Example Revisited:
  • The sendMessage() method in the Dispatcher is being executed in the caller's thread of execution
• The Defect:
  • This method won't return until there are vehicles available which could be a problem for both the RealTimeDispatchHandler and the DailyDispatchHandler

• Going Further with this Example:
  • The actual sending of the message (e.g., using the Internet) may take time
• The Defect:
  • Only one vehicle can be dispatched "at a time"

• "Fixing" One Aspect:
  • Have sendMessage() add tasks to a queue and return "immediately"
• "Fixing" the Other Aspect:
  • Use a thread for each task in the queue
• The "Mistake":
  • Coupling the task to be performed with the way it is executed

• The Interface:
  • Executor
• Methods:
  • execute(Runnable task)
• How It's Used:
  1. Construct an Executor
  2. Construct one or more Runnable objects that encapsulate the task(s) to be performed
  3. Call execute()

• The Issue:
  • Constructing objects that implement these interfaces can be complicated so use a factory
• The Class:
  • Executors
• Some Methods:
  • newCachedThreadPool()
  • newFixedThreadPool(n)
  • newSchedueldThreadPool(n)
  • newSingleThreadExecutor()
  • newSingleThreadExecutorService()

• A Complication of Decoupling:
  • The termination of tasks and waiting for tasks to terminate needs to be handled by the executor (i.e., since we don't know what Thread is being used, we can't` call its interrupt() or join() methods)
• The Solution:
  • Add capabilities by specializing the Executor interface (i.e., create a subinterface)

• The Subinterface:
  • ExecutorService
• Methods:
  • submit(task)
  • awaitTermination(time, timeunit)
  • shutdown()
  • shutdownNow()
  • isShutdown()
  • isTerminated()

try
{
    executor.shutdown();
    executor.awaitTermination(WAIT, TimeUnit.SECONDS);
}
catch (InterruptedException ie)
{
}
finally
{
    if (!executor.isTerminated())
    {

    }
    executor.shutdownNow();
}
  

• The Situation:
  • We want to perform the same task more than once
• Approaches:
  • Have the task itself handle the repetition
  • Execute a "one-shot" task multiple times

A Repeating Task

javaexamples/threads_executor/v1/RepeatingDirectoryLister.java

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

/**
 * A RepeatingDirectoryLister will repeatedly save a directory listing
 * to the file system (in its own thread of execution).
 *
 * @author  Prof. David Bernstein, James Madison University
 * @version 1.0
 */
public class RepeatingDirectoryLister implements Runnable
{
    private volatile boolean keepRunning;
    private long             delay;
    private Thread           thread;

    /**
     * Explicit Value Constructor.
     *
     * @param delay  The delay between snapshots
     */
    public RepeatingDirectoryLister(long delay)
    {
        this.delay = delay;
    }

    /**
     * The code to execute.
     */
    public void run()
    {
        File        wd;
        File[]      listing;
        PrintStream out;

        wd = new File(".");

        while (keepRunning)
        {
            // Create the PrintStream for the snapshot
            try
            {
                out = new PrintStream(new File("directory.snp"));
            }
            catch (FileNotFoundException fnfe)
            {
                out = System.out;
            }

            // Create the snapshot
            out.println("Contents of " + wd + " at " + new Date());            
            listing = wd.listFiles();
            for (int i=0; i<listing.length; i++)
            {
                out.println(listing[i]);
            }
            out.close();

            // Sleep until it is time for the next snapshot
            try
            {
                thread.sleep(delay);
            }
            catch (InterruptedException ie)
            {
            }
        }
        thread = null;
    }
    
    /**
     * Start this RepeatingDirectoryLister.
     */
    public void start()
    {
        if (thread == null)
        {
            keepRunning = true;
            thread = new Thread(this);
            thread.start();
        }
    }

    /**
     * Stop this RepeatingDirectoryLister.
     */
    public void stop()
    {
        keepRunning = false;
        thread.interrupt();
    }
    

}
        

The Main Class

javaexamples/threads_executor/v1/AutoDir.java

import java.io.*;

/**
 * A utility application that repeatedly saves a snapshot of the files in the
 * current directory.
 *
 * This version uses a RepeatingDirectoryLister

 * @author  Prof. David Bernstein, James Madison University
 * @version 1
 */
public class AutoDir
{
    /**
     * The entry point of the application.
     *
     * args[0] contains the delay between snapshots.
     *
     * @param args The command-line arguments.
     */
    public static void main(String[] args) throws IOException
    {
        long        delay;

        // Process the command-line arguments
        delay = 1000;
        if ((args != null) && (args.length > 0))
        {
            delay = Long.parseLong(args[0]);
        }
        

        // Construct and start the RepeatingDirectoryLister
        RepeatingDirectoryLister rdl = new RepeatingDirectoryLister(delay);
        rdl.start();

        // The command-line "user interface" (such as it is)
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        System.out.println("Press [Enter] to stop.");
        in.readLine();
        rdl.stop();
    }
}
        

• What's Needed for the Decoupled Approach?
  • An ExecutorService that can repeatedly execute a task
• The Subinterface:
  • ScheduledExecutorService
• Methods:
  • schedule(task, delay, timunit)
  • scheduleAtFixedRate(task, initialDelay, period, timeunit)
  • scheduleWithFixedDelay(task, initialDelay, delay, timunit)

A "One-Shot" Task

javaexamples/threads_executor/v2/DirectoryLister.java

import java.io.*;

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

/**
 * A Runnable that will save a directory listing to the file system.
 *
 * @author  Prof. David Bernstein, James Madison University
 * @version 1.0
 */
public class DirectoryLister implements Runnable
{
    /**
     * The code to execute.
     */
    public void run()
    {
        File        wd;
        File[]      listing;
        PrintStream out;        

        wd = new File(".");

        // Create the PrintStream for the snapshot
        try
        {
            out = new PrintStream(new File("directory.snp"));
        }
        catch (FileNotFoundException fnfe)
        {
            out = System.out;
        }

        // Print the header
        out.println("Contents of " + wd + " at " + new Date());            
        
        // Create the snapshot
        listing = wd.listFiles();
        for (int i=0; i<listing.length; i++)
        {
            out.println(listing[i]);
        }

        out.close();
    }
}
        

The Main Class using a ScheduledExecutorService

javaexamples/threads_executor/v2/AutoDir.java

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


/**
 * A utility application that repeatedly saves a snapshot of the files in the
 * current directory.
 *
 * This version uses a DirectoryLister and a ScheduledExecutorService.

 * @author  Prof. David Bernstein, James Madison University
 * @version 2
 */
public class AutoDir
{
    /**
     * The entry point of the application.
     *
     * args[0] contains the delay between snapshots.
     *
     * @param args The command-line arguments.
     */
    public static void main(String[] args) throws IOException
    {
        long        delay;
        
        // Process the command-line arguments
        delay = 1000;
        if ((args != null) && (args.length > 0))
        {
            delay = Long.parseLong(args[0]);
        }
        
        // Construct and start the DirectoryLister
        ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
        scheduler.scheduleAtFixedRate(new DirectoryLister(), 0, delay,
                                      TimeUnit.MILLISECONDS);
        
        // The command-line "user interface" (such as it is)
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        System.out.println("Press [Enter] to stop.");
        in.readLine();

        scheduler.shutdownNow();
    }
}
        

• A Limitation:
  • Since Runnable is void, the tasks can't return anything (except indirectly through reference parameters that are passed in)
• An Easy Fix Ignoring Threads:
  • The Callable interface has a call() method that returns a parameterized type
• The Complication of Threads:
  • In a multi-threaded application the task will be performed asynchronously so the result won't be immediately available

• The Interface:
  • Future
• Purpose:
  • Represents the result of an asynchronous task
• Methods:
  • get() - wait for the task to complete (perhaps for a maximum amount of time)
  • isDone() - determine if the task is complete
  • cancel() - attempt to cancel the task
  • isCancelled() - determine if the task was cancelled before completion
• An Observation:
  • A Future can be used like a latch

A Revised "One-Shot" Task

javaexamples/threads_executor/v3/DirectoryLister.java

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

/**
 * A Runnable that will save a directory listing to the file system.
 *
 * This version implements the Callable interface so that it can return
 * the number of files in the directory.
 *
 * @author  Prof. David Bernstein, James Madison University
 * @version 3.0
 */
public class DirectoryLister implements Callable<Integer>
{
    /**
     * The code to execute.
     */
    public Integer call()
    {
        File        wd;
        File[]      listing;
        PrintStream out;        

        wd = new File(".");

        // Create the PrintStream for the snapshot
        try
        {
            out = new PrintStream(new File("directory.snp"));
        }
        catch (FileNotFoundException fnfe)
        {
            out = System.out;
        }

        // Print the header
        out.println("Contents of " + wd + " at " + new Date());            
        
        // Create the snapshot
        listing = wd.listFiles();
        for (int i=0; i<listing.length; i++)
        {
            out.println(listing[i]);
        }

        out.close();

        return new Integer(listing.length);
    }
}
        

Using the Return Value

javaexamples/threads_executor/v3/AutoDir.java

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


/**
 * A utility application that repeatedly saves a snapshot of the files in the
 * current directory.
 *
 * This version uses schules several DirectoryLister objects and waits for
 * them to complete. Also, this version can't be terminated.
 *
 * @author  Prof. David Bernstein, James Madison University
 * @version 3
 */
public class AutoDir
{
    /**
     * The entry point of the application.
     *
     * args[0] contains the delay between snapshots.
     *
     * @param args The command-line arguments.
     */
    public static void main(String[] args) throws IOException
    {
        int         n;        
        long        delay;
        
        // Process the command-line arguments
        delay = 60000; // Every sixty seconds
        n     = 60;    // For an hour
        
        if ((args != null) && (args.length > 1))
        {
            delay = Long.parseLong(args[0]);
            n     = Integer.parseInt(args[1]);
        }
        
        // Create the ExecutorService
        ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
        // Construct and schedule multiple DirectoryLister objects
        ScheduledFuture<Integer>[] result = new ScheduledFuture[n];
        for (int i=0; i<n; i++)
        {
            result[i] = scheduler.schedule(new DirectoryLister(), i*delay,
                                           TimeUnit.MILLISECONDS);
        }
        
        // Wait for and then print the number of files in the directory
        for (int i=0; i<result.length; i++)
        {
            try
            {
                System.out.printf("Number of Files: %d\n", 
                                  result[i].get().intValue());
            }
            catch (ExecutionException ie)
            {
                System.out.println("Number of Files: Unavailable\n");
            }
            catch (InterruptedException ie)
            {
                System.out.println("Number of Files: Unavailable\n");
            }
        }
        

        // Shutdown the ExecutorService
        scheduler.shutdownNow();
    }
}
        

• An Observation:
  • A Future object can be useful even when the task does not return anything since it provides other functionality
• Our Current Interest:
  • A Future object has a cancel() method
• A Detail:
  • The Future object can be parameterized using ? to indicate that we don't care about the return type

A Terminator Task

javaexamples/threads_executor/v4/Terminator.java

import java.util.concurrent.*;


/**
 * A Runnable that can be used to cancel a Future and shutdown the
 * ExecutorService.
 *
 * @author  Prof. David Bernstein, James Madison University
 * @version 1.0
 */
public class Terminator implements Runnable
{
    ExecutorService  service;
    Future<?>        future;    

    /**
     * Explicit Value Constructor.
     *
     * @param future   The Future to be cancelled.
     * @param service  The ExecutorService
     */
    public Terminator(Future<?> future, ExecutorService service)
    {
        this.future  = future;
        this.service = service;
    }
    

    /**
     * The code to execute.
     */
    public void run()
    {
        // Cancel the Future
        future.cancel(true);

        // Shutdown the ExecutorService
        try
        {
            service.shutdown();
            service.awaitTermination(2000, TimeUnit.MILLISECONDS);
        }
        catch (InterruptedException ie)
        {
        }
        finally
        {
            service.shutdownNow();
        }
    }
}
        

Scheduling a Terminator Task

javaexamples/threads_executor/v4/AutoDir.java

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


/**
 * A utility application that repeatedly saves a snapshot of the files in the
 * current directory.
 *
 * This version runs for a specific amount if time; it does not have
 * a UI that can be used to shut it down.

 * @author  Prof. David Bernstein, James Madison University
 * @version 4
 */
public class AutoDir
{
    /**
     * The entry point of the application.
     *
     * args[0] contains the delay between snapshots.
     *
     * @param args The command-line arguments.
     */
    public static void main(String[] args) throws IOException
    {
        long        delay, duration;
        
        // Process the command-line arguments
        delay    =   60000;  // Once per minute
        duration = 3600000;  // For an hour
        
        if ((args != null) && (args.length > 1))
        {
            delay    = Long.parseLong(args[0]);
            duration = Long.parseLong(args[1]);
        }
        
        // Construct the scheduler
        ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
        // Construct and schedule the DirectoryLister
        Future<?> task;
        task = scheduler.scheduleAtFixedRate(new DirectoryLister(), 0, delay,
                                             TimeUnit.MILLISECONDS);
        
        // Construct and schedule the Terminator
        scheduler.schedule(new Terminator(task, scheduler), 
                           duration, TimeUnit.MILLISECONDS);
    }
}
        

• Executor and ExecutorService:
  • Actions in a thread prior to the submission of a Runnable to an Executor happen-before its execution begins
  • Actions in a thread prior to the submission of a Callable to an ExecutorService happen-before its execution begins
• Future:
  • Actions taken by the asynchronous computation represented by a Future happen-before actions subsequent to the retrieval of the result via Future.get() in another thread

• Executors:
  • newWorkStealingPool()
• Fork-Join Computation:
  • ForkJoinTask
  • ForkJoinWorkerThread
  • ForkJoinPool
• Graphical User Interfaces:
  • SwingWorker