What are the advantages of using an ExecutorService?

Question

What is the advantage of using ExecutorService over running threads passing a Runnable into the Thread constructor?

Answer 1

Prior to java 1.5 version, Thread/Runnable was designed for two separate services

1. Unit of work
2. Execution of that unit of work

ExecutorService decouples those two services by designating Runnable/Callable as unit of work and Executor as a mechanism to execute ( with lifecycling) the unit of work

Answer 2

Below are some benefits:

1. Executor service manage thread in asynchronous way
2. Use Future callable to get the return result after thread completion.
3. Manage allocation of work to free thread and resale completed work from thread for assigning new work automatically
4. fork - join framework for parallel processing
5. Better communication between threads
6. invokeAll and invokeAny give more control to run any or all thread at once
7. shutdown provide capability for completion of all thread assigned work
8. Scheduled Executor Services provide methods for producing repeating invocations of runnables and callables Hope it will help you

Answer 3

The following limitations from traditional Thread overcome by Executor framework(built-in Thread Pool framework).

• Poor Resource Management i.e. It keep on creating new resource for every request. No limit to creating resource. Using Executor framework we can reuse the existing resources and put limit on creating resources.
• Not Robust : If we keep on creating new thread we will get StackOverflowException exception consequently our JVM will crash.
• Overhead Creation of time : For each request we need to create new resource. To creating new resource is time consuming. i.e. Thread Creating > task. Using Executor framework we can get built in Thread Pool.

Benefits of Thread Pool

• Use of Thread Pool reduces response time by avoiding thread creation during request or task processing.

• Use of Thread Pool allows you to change your execution policy as you need. you can go from single thread to multiple thread by just replacing ExecutorService implementation.

• Thread Pool in Java application increases stability of system by creating a configured number of threads decided based on system load and available resource.

• Thread Pool frees application developer from thread management stuff and allows to focus on business logic.

Source

Answer 4

An advantage I see is in managing/scheduling several threads. With ExecutorService, you don't have to write your own thread manager which can be plagued with bugs. This is especially useful if your program needs to run several threads at once. For example you want to execute two threads at a time, you can easily do it like this:

ExecutorService exec = Executors.newFixedThreadPool(2);

exec.execute(new Runnable() {
  public void run() {
    System.out.println("Hello world");
  }
});

exec.shutdown();

The example may be trivial, but try to think that the "hello world" line consists of a heavy operation and you want that operation to run in several threads at a time in order to improve your program's performance. This is just one example, there are still many cases that you want to schedule or run several threads and use ExecutorService as your thread manager.

For running a single thread, I don't see any clear advantage of using ExecutorService.

Answer 5

Is it really that expensive to create a new thread?

As a benchmark, I just created 60,000 threads with Runnables with empty run() methods. After creating each thread, I called its start(..) method immediately. This took about 30 seconds of intense CPU activity. Similar experiments have been done in response to this question. The summary of those is that if the threads do not finish immediately, and a large number of active threads accumulate (a few thousand), then there will be problems: (1) each thread has a stack, so you will run out of memory, (2) there might be a limit on the number of threads per process imposed by the OS, but not necessarily, it seems.

So, as far as I can see, if we're talking about launching say 10 threads per second, and they all finish faster than new ones start, and we can guarantee that this rate won't be exceeded too much, then the ExecutorService doesn't offer any concrete advantage in visible performance or stability. (Though it may still make it more convenient or readable to express certain concurrency ideas in code.) On the other hand, if you might be scheduling hundreds or thousands of tasks per second, which take time to run, you could run into big problems straight away. This might happen unexpectedly, e.g. if you create threads in response to requests to a server, and there is a spike in the intensity of requests that your server receives. But e.g. one thread in response to every user input event (key press, mouse motion) seems to be perfectly fine, as long as the tasks are brief.

Answer 6

ExecutorService also gives access to FutureTask which will return to the calling class the results of a background task once completed. In the case of implementing Callable

public class TaskOne implements Callable<String> {

@Override
public String call() throws Exception {
    String message = "Task One here. . .";
    return message;
    }
}

public class TaskTwo implements Callable<String> {

@Override
public String call() throws Exception {
    String message = "Task Two here . . . ";
    return message;
    }
}

// from the calling class

ExecutorService service = Executors.newFixedThreadPool(2);
    // set of Callable types
    Set<Callable<String>>callables = new HashSet<Callable<String>>();
    // add tasks to Set
    callables.add(new TaskOne());
    callables.add(new TaskTwo());
    // list of Future<String> types stores the result of invokeAll()
    List<Future<String>>futures = service.invokeAll(callables);
    // iterate through the list and print results from get();
    for(Future<String>future : futures) {
        System.out.println(future.get());
    }