Thread Executors

Thread Executors

            A task is defined as a small independent activity that represents some unit of work that starts at some point, requires some activity or computation, and then terminates. In a web server, each individual incoming request meets this definition. In Java, these are represented by instances of Runnable or Callable.

            A thread can be considered to be a running instance of a task. If a task represents some unit of work that needs to be done, then a thread represents the actual performance of that task. In Java, these are represented by instances of Thread.

            Synchronous processing occurs when a task must be done in the main thread of execution. In other words, the main program must wait until the current task is done, before it can continue on with its processing.

            Asynchronous processing is when the main thread delegates the processing of a task to a separate independent thread. That thread is then responsible for the processing associated with the task, while the main thread returns to doing whatever main programs do.

            A thread pool represents one or more threads sitting around waiting for work to be assigned to them. A pool of threads brings a number of advantages to the party. First, it limits the cost of setting up and tearing down threads, since threads in the pool are reused rather than created from scratch each time. Second, it can serve to limit the total number of active threads in the system, which reduces the memory and computing burdens on the server. Finally, it lets you delegate the problem of managing threads to the pool, simplifying your application.

At this point, it is important to note that there are three critical mechanisms at work here – there’s the arrival of tasks to be processed (someone is requesting some units of work to be done), there is the submission of tasks to some holding tank, and then there’s the actual processing of each task. The Executor framework in Java separates the latter two mechanisms – submission and processing.

The arrival of requests is generally out of the control of the program – and may be driven by requests from clients. The submission of a request is typically made by requesting that the task be added to a queue of incoming tasks, while the processing is implemented using a pool of threads that sit idle waiting to be assigned an incoming task to process.

            An Executor provides application programs with a convenient abstraction for thinking about tasks. Rather than thinking in terms of threads, an application now deals simply with instances of Runnable, which it then passes to an Executor to process.

public interface Executor {
     public void execute(Runnable command);
   }

To use the thread pooling framework, you create an Executor instance, then you pass it some runnable tasks:

Executor executor = ...;    executor.execute(aRunnable1);    executor.execute(aRunnable2);

            The ExecutorService interface extends the simplistic Executor interface, by adding lifecycle methods to manage the threads in the pool. For instance, you can shutdown the threads in the pool.

            In addition, while the Executor lets you submit a single task for execution by a thread in the pool, the ExecutorService lets you submit a collection of tasks for execution, or to obtain a Future object that you can use to track the progress of that task.

        public interface ExecutorService extends Executor

            An ExecutorService can be shut down, which will cause it to stop accepting new tasks. After being shut down, the executor will eventually terminate, at which point no tasks are actively executing, no tasks are awaiting execution, and no new tasks can be submitted.

            The Executor framework represents tasks using instances of either Runnable or Callable. Runnable‘s run() method is limiting in that it cannot return a value, nor throw a checked exception.  Callable is a more functional version, and defines a call() method that allows the return of some computed value, and even throwing an exception if necessary.

Algorithm for using an Executor

1.  Create an Executor           

• Create an instance of an Executor or ExecutorService
• Executor executor = Executors.newFixedThreadPool(10);

           

            Type of thread pools you can create with the Executors class

• Single Thread Executor : A thread pool with only one thread. So all the submitted task will be executed sequentially. Method : Executors.newSingleThreadExecutor()
• Cached Thread Pool : A thread pool that create as many threads it needs to execute the task in parralel. The old available threads will be reused for the new tasks. If a thread is not used during 60 seconds, it will be terminated and removed from the pool. Method : Executors.newCachedThreadPool()
• Fixed Thread Pool : A thread pool with a fixed number of threads. If a thread is not available for the task, the task is put in queue waiting for an other task to ends. Method : Executors.newFixedThreadPool()
• Scheduled Thread Pool : A thread pool made to schedule future task. Method : Executors.newScheduledThreadPool()
• Single Thread Scheduled Pool : A thread pool with only one thread to schedule future task. Method : Executors.newSingleThreadScheduledExecutor()

2. Create one or more tasks

• One or more tasks to be performed as instances of either Runnable or Callable.

3. Submit the task to the Executor

• Invoke submit() or execute() methods

4. Execute the task

• Pool will automatically dequeue the tasks and execute it.

5. Shutdown the Executor

• Invoke its shutdown() method




Example Program

public class NamePrinter implements Runnable {
     private final String name;
     private final int delay;
     public NamePrinter(String name, int delay) {
       this.name = name;
       this.delay = delay;
     }
     public void run() {
       System.out.println("Starting: " + name);
       try {
         Thread.sleep(delay);
       } catch (InterruptedException ignored) {
       }
       System.out.println("Done with: " + name);
     }
   }

import java.util.concurrent.*;    import java.util.Random;          public class UsePool {      public static void main(String args[]) {        Random random = new Random();        ExecutorService executor =                Executors.newFixedThreadPool(3);        // Sum up wait times to know when to shutdown        int waitTime = 500;        for (int i=0; i<10; i++) {          String name = "NamePrinter " + i;          int time = random.nextInt(1000);          waitTime += time;          Runnable runner = new NamePrinter(name, time);          System.out.println("Adding: " + name + " / " + time);          executor.execute(runner);        }        try {          Thread.sleep(waitTime);          executor.shutdown();          executor.awaitTermination                  (waitTime, TimeUnit.MILLISECONDS);        } catch (InterruptedException ignored) {        }        System.exit(0);      }     }

Compile NamePrinter and UsePool, then run UsePool. Here's a sample output run -- note that each run will be unique with the random sleeps present:

   Adding: NamePrinter 0 / 30

   Adding: NamePrinter 1 / 727

   Adding: NamePrinter 2 / 980

   Starting: NamePrinter 0

   Starting: NamePrinter 1

   Starting: NamePrinter 2

   Adding: NamePrinter 3 / 409

   Adding: NamePrinter 4 / 49

   Adding: NamePrinter 5 / 802

   Adding: NamePrinter 6 / 211

   Adding: NamePrinter 7 / 459

   Adding: NamePrinter 8 / 994

   Adding: NamePrinter 9 / 459  

   Done with: NamePrinter 0

   Starting: NamePrinter 3

   Done with: NamePrinter 3

   Starting: NamePrinter 4

   Done with: NamePrinter 4

   Starting: NamePrinter 5

   Done with: NamePrinter 1

   Starting: NamePrinter 6

   Done with: NamePrinter 6

   Starting: NamePrinter 7

   Done with: NamePrinter 2

   Starting: NamePrinter 8

   Done with: NamePrinter 5

   Starting: NamePrinter 9

   Done with: NamePrinter 7

   Done with: NamePrinter 9

   Done with: NamePrinter 8

Notice that the first three NamePrinter objects started quickly. Later NamePrinter objects started as each executing NamePrinter object finished.