"implements Runnable" vs "extends Thread" in Java

java

concurrency

threading

best-practices

byNikita Barsukov·Sep 5, 2024

Opt for implements Runnable for design flexibility and good software architecture:

public class MyTask implements Runnable {
    public void run() { /* Your task code which is more runnable than Usain Bolt */ }
}
new Thread(new MyTask()).start();

Keeps possibilities open for your class to inherit from another class.
Emphasizes composition over inheritance, staying true to good OOP principles.

Choose extends Thread for simpler scenarios or when you need to customize thread behavior:

public class MyThread extends Thread {
    public void run() { /* Your smooth-running code (no thread-mills here) */ }
}
new MyThread().start();

Ties your class implementation to the Thread class.
Not ideal when inheritance from another class is required.

The Art of Choosing: Runnable vs Thread

Favouring Composition over Inheritance

When crafting classes, composition over inheritance is the OOP golden rule. Runnable implementation keeps the inheritance tree open, allowing class inheritance from another crucial class while still representing a concurrent task.

A key advantage of Runnable is the ability to be executed by different threads. This introduces an elegant way of running the same task in various threads, something that is not easily achievable when extending Thread as each class instance corresponds to a single thread.

Better Together with Executor Framework

With the advent of the Executor Framework, task-oriented programming is leading the way. Using Runnable makes your tasks compatible with ThreadPoolExecutor or Executors.newCachedThreadPool(), managing a pool of threads for you, achieving maximum efficiency, and handling the low-level thread management.

Preparing for the Future with Callable

When tasks need to generate an outcome, Runnable won't suffice. This is where Callable<V> and FutureTask<V> come into play, letting you execute tasks that return a result and adding more functionality to the concurrency API.

Empowered by Java 8 Features

Java 8's introduction of lambda expressions simplifies syntax when working with Runnable, fostering more concise and maintainable code:

Runnable task = () -> { /* Task code running faster than a cheetah on caffeine */ };
new Thread(task).start();

Customizing Threads

The Thread of Custom Behavior

In some scenarios, you may need to extend the Thread class directly. These cases include the creation of a specialized thread with properties or behaviors that a plain Runnable or Thread class cannot offer.

Inheritance: A Powerful Yet Restrictive Tool

While extending Thread may seem straightforward, it comes with an inheritance caveat. If you take this path, your class can't extend any other class. This can result in design constraints.

Practical Use Cases & Potential Pitfalls

Service-oriented Concurrency

Imagine a web server that handles multiple client requests concurrently. Implementing Runnable allows individual threads to service client requests using the same task logic, decoupling task execution from thread life-cycle.

Promoting Reusability

For recurring tasks like clean-up jobs or health-check processes, implementing Runnable gives you the freedom to schedule that task using different timing strategies with a ScheduledExecutorService.

Tackling Limitations

Using Thread directly may introduce complexity when handling multiple tasks. There's a risk of falling into bad habits like incorrectly overriding methods or mismanaging thread states.

Making the Right Decision

Deciding between Runnable and Thread involves:

Design Elegance: Runnable endorses clean task-execution separation.
Flexibility and Reusability: Runnable fits different execution contexts.
Room for Growth: Runnable lets you inherit from other classes.
Simplicity: Thread seems simple but can bring unnecessary complexity.

Always lean towards Runnable for a task-oriented approach, unless you have a firm reason to extend Thread. Separating the concern of a task and its execution is a foundation of Java design and is advocated by best practices. It transcends writing code into crafting systems that are maintainable and scalable.

explain-codes / Java / "implements Runnable" vs "extends Thread" in Java

Linked

Threading pool similar to the multiprocessing Pool?



The AsyncTask API is deprecated in Android 11. What are the alternatives?



Custom thread pool in Java 8 parallel stream



How is CountDownLatch used in Java Multithreading?



Java Delegates?

