Implementing a Runnable vs Extending a Thread

1. Introduction

“Should I implement a Runnable or extend the Thread class”? is quite a common question.

In this article, we’ll see which approach makes more sense in practice and why.

2. Using Thread

Let’s first define a SimpleThread class that extends Thread:

public class SimpleThread extends Thread {

    private String message;

    // standard logger, constructor

    @Override
    public void run() {
        log.info(message);
    }
}

Let’s also see how we can run a thread of this type:

@Test
public void givenAThread_whenRunIt_thenResult()
  throws Exception {
 
    Thread thread = new SimpleThread(
      "SimpleThread executed using Thread");
    thread.start();
    thread.join();
}

We can also use an ExecutorService to execute the thread:

@Test
public void givenAThread_whenSubmitToES_thenResult()
  throws Exception {
    
    executorService.submit(new SimpleThread(
      "SimpleThread executed using ExecutorService")).get();
}

That’s quite a lot of code for running a single log operation in a separate thread.

Also, note that SimpleThread cannot extend any other class, as Java doesn’t support multiple inheritance.

3. Implementing a Runnable

Now, let’s create a simple task which implements the java.lang.Runnable interface:

class SimpleRunnable implements Runnable {
	
    private String message;
	
    // standard logger, constructor
    
    @Override
    public void run() {
        log.info(message);
    }
}

The above SimpleRunnable is just a task which we want to run in a separate thread.

There’re various approaches we can use for running it; one of them is to use the Thread class:

@Test
public void givenRunnable_whenRunIt_thenResult()
 throws Exception {
    Thread thread = new Thread(new SimpleRunnable(
      "SimpleRunnable executed using Thread"));
    thread.start();
    thread.join();
}

We can even use an ExecutorService:

@Test
public void givenARunnable_whenSubmitToES_thenResult()
 throws Exception {
    
    executorService.submit(new SimpleRunnable(
      "SimpleRunnable executed using ExecutorService")).get();
}

We can read more about ExecutorService in here.

Since we’re now implementing an interface, we’re free to extend another base class if we need to.

Starting with Java 8, any interface which exposes a single abstract method is treated as a functional interface, which makes it a valid lambda expression target.

We can rewrite the above Runnable code using a lambda expression:

@Test
public void givenARunnableLambda_whenSubmitToES_thenResult() 
  throws Exception {
    
    executorService.submit(
      () -> log.info("Lambda runnable executed!"));
}

4. Runnable or Thread?

Simply put, we generally encourage the use of Runnable over Thread:

  • When extending the Thread class, we’re not overriding any of its methods. Instead, we override the method of Runnable (which Thread happens to implement). This is a clear violation of IS-A Thread principle
  • Creating an implementation of Runnable and passing it to the Thread class utilizes composition and not inheritance – which is more flexible
  • After extending the Thread class, we can’t extend any other class
  • From Java 8 onwards, Runnables can be represented as lambda expressions

5. Conclusion

In this quick tutorial, we saw how implementing Runnable is typically a better approach than extending the Thread class.

The code for this post can be found over on GitHub.

Related posts:

Using the Map.Entry Java Class
Spring – Injecting Collections
Find the Registered Spring Security Filters
Returning Image/Media Data with Spring MVC
Most commonly used String methods in Java
Feign – Tạo ứng dụng Java RESTful Client
Java Program to Use Boruvka’s Algorithm to Find the Minimum Spanning Tree
Notify User of Login From New Device or Location
Java Program to Perform Insertion in a BST
Java Program to Implement Multi-Threaded Version of Binary Search Tree
Java Program to Implement Borwein Algorithm
Java Program to do a Breadth First Search/Traversal on a graph non-recursively
Request a Delivery / Read Receipt in Javamail
Java Program to Implement the linear congruential generator for Pseudo Random Number Generation
How to Set TLS Version in Apache HttpClient
Creating a Web Application with Spring 5
Loại bỏ các phần tử trùng trong một ArrayList như thế nào?
New Features in Java 9
Java Program to Find MST (Minimum Spanning Tree) using Prim’s Algorithm
Java Program to Check Whether a Directed Graph Contains a Eulerian Cycle
Spring Boot - Eureka Server
Adding Parameters to HttpClient Requests
Java Program to Implement Floyd Cycle Algorithm
Java Program to Implement a Binary Search Algorithm for a Specific Search Sequence
Java Program to Compute Discrete Fourier Transform Using the Fast Fourier Transform Approach
Java Program to Implement Segment Tree
Java Program to Implement Selection Sort
Java Program to Generate N Number of Passwords of Length M Each
Một số từ khóa trong Java
Java Program to Implement LinkedHashMap API
Java Program to Test Using DFS Whether a Directed Graph is Strongly Connected or Not
Apache Commons Collections MapUtils