Thread vs. Single Thread Executor Service

1. Overview

Threads and the Executor Framework are two mechanisms used to execute code in parallel in Java. This improves the performance of the application. The Executor Framework provides different kinds of thread pools. One of the pools comprises just a single worker thread.

In this tutorial, we’ll learn the difference between a thread and an executor service having a single worker thread.

2. Thread

A thread is a lightweight process having a separate path of execution. It’s used to execute tasks in parallel. Thus, there can be multiple threads running simultaneously without interfering with each other.

A Thread object executes Runnable tasks.

Let’s see how we can create threads. We can create threads either by extending the Thread class or by implementing the Runnable interface.

Let’s create a thread by extending the Thread class:

public class CustomThread extends Thread {
    // override the run() method to provide custom implementation

    public static void main(String[] args) { 
        CustomThread t1 = new CustomThread();
        t1.start(); 
    } 
}

In the above example, CustomThread class extends the Thread class. And in the main() method, we’ve created the object of CustomThread class and then called its start() method. It begins the execution of the thread.

Now let’s look at an example of creating a thread by implementing the Runnable interface:

public class TestClass implements Runnable {
    // implement the run() method of Runnable interface
   
    public static void main(String[] args) {
        TestClass testClassRef = new TestClass();
        Thread t1 = new Thread(testClassRef);
        t1.start();
    }
}

In the example above, TestClass implements the Runnable interface. We pass the reference of the TestClass object in the constructor of the Thread class. And then, we call the start() method. This, in turn, calls the run() method implemented by TestClass.

3. Executor Framework

Now we’ll learn about the Executor Framework. It was introduced in JDK 1.5. It’s a multi-threading framework that maintains a pool of worker threads and manages them. The tasks are submitted in a queue and are then executed by these worker threads.

It removes the overhead of creating threads explicitly in the code. Instead, it reuses the threads in the pool for executing tasks asynchronously.

Let’s now look at different kinds of thread pools maintained by the Executor Framework.

3.1. Fixed Thread Pool

This pool contains a fixed number of threads. We specify the number of threads during the creation of the pool. If an exception occurs and a thread is terminated, a new one gets created.

Let’s see how to create a fixed thread pool:

ExecutorService executorService = Executors.newFixedThreadPool(5);

In the above code snippet, we created a fixed thread pool with five worker threads.

3.2. Cached Thread Pool

This thread pool creates new threads when required. If no thread is available to execute the submitted task, then a new thread will be created.

Here’s how we create a cached thread pool:

ExecutorService executorService = Executors.newCachedThreadPool();

In the cached thread pool, we don’t mention the pool size. This is because it creates new threads when none are available to execute the submitted task. It also reuses already created threads when they’re available.

3.3. Scheduled Thread Pool

This thread pool runs tasks after a given delay or periodically.

Here’s how we can create a scheduled thread pool:

ScheduledExecutorService executorService = Executors.newScheduledThreadPool(5);

In the above code snippet, the integer parameter is the core pool size. It represents the number of threads to keep in the pool, even if they’re idle.

3.4. Single Thread Pool

This pool consists of just one thread. It executes the submitted tasks sequentially. If an exception occurs and the thread gets terminated, a new one is created.

Below code snippet shows how to create a single thread pool:

ExecutorService executorService = Executors.newSingleThreadExecutor();

Here, the Executors class’s static method newSingleThreadExecutor() creates ExecutorService consisting of a single worker thread.

4. Thread vs. Single Thread Executor Service

We may wonder if a single thread pool ExecutorService contains just one thread, then how it’s different from creating a thread explicitly and using it to execute the task.

Let’s now explore the differences between a thread and an executor service with just one worker thread and when to use which.

4.1. Task Handling

Threads can only handle Runnable tasks, whereas a single thread executor service can execute both Runnable and Callable tasks. Therefore, using this, we can also run tasks that can return some value.

The submit() method in the ExecutorService interface takes either a Callable task or a Runnable task and returns a Future object. This object represents the result of an asynchronous task.

Also, a thread can handle just one task and exit. But a single thread executor service can handle a series of tasks and executes them sequentially.

4.2. Thread Creation Overhead

There is an overhead involved in creating threads. For instance, JVM needs to allocate memory. It impacts performance when threads are created repeatedly in the code. But in the case of a single thread executor service, the same worker thread is reused. Therefore, it prevents the overhead of creating multiple threads.

4.3. Memory Consumption

Thread objects take a significant amount of memory. Therefore, if we create threads for each asynchronous task, it can lead to OutOfMemoryError. But in a single thread executor service, the same worker thread is reused, which leads to less memory consumption.

4.4. Release of Resources

A thread releases resources once its execution completes. But in the case of executor service, we need to shut down the service or the JVM won’t be able to shut down. Methods like shutdown() and shutdownNow() shutdown the executor service.

5. Conclusion

In this article, we learned about threads, the Executor Framework, and different kinds of thread pools. We also saw differences between a thread and the single thread executor service.

We learned that if there’s any repeated job or if there are many asynchronous tasks, then the executor service is a better choice.