Runnable vs Thread in Java: Differences and When to Use Each

In Java, Runnable is an interface that describes a task to run, whereas Thread is the class that runs a task on its own thread of execution. In the Runnable vs Thread choice, we implement Runnable (or write a lambda) and pass it to a Thread or an executor, and we extend Thread only when we change how the thread itself behaves.

The question comes up every time we write background work, such as sending a receipt email after checkout or refreshing a cache, and the answer decides whether that code can later move to a thread pool or a virtual thread without a rewrite.

The following example runs the same kind of work both ways and counts the sent receipts.

AtomicInteger sent = new AtomicInteger();
Runnable sendReceipt = sent::incrementAndGet;     // a task, no thread yet

Thread worker = new Thread(sendReceipt);          // Runnable handed to a Thread
worker.start();
worker.join();

Thread subclass = new Thread() {                  // Thread subclass overriding run()
    @Override
    public void run() {
        sent.incrementAndGet();
    }
};
subclass.start();
subclass.join();
int total = sent.get();                           // 2

Notice that both versions end with start() on a Thread object, because only a Thread can start a new thread. The difference is where the work lives. We look at each type first, compare them in a table, and finish with the rare cases where subclassing Thread still fits.

1. Thread Class

The Thread class represents a thread of execution in a Java program. It holds the thread name, priority, daemon flag and state, and its start() method asks the JVM to create the thread and call run() on it. To use it by inheritance, we extend Thread in a child class and override run().

class ReceiptThread extends Thread {
    private final String orderId;

    ReceiptThread(String orderId) {
        super("receipt-" + orderId);
        this.orderId = orderId;
    }

    @Override
    public void run() {
        ReceiptLog.record(orderId + " sent by " + getName());
    }
}

class ReceiptLog {
    static final List<String> LINES = new CopyOnWriteArrayList<>();

    static void record(String line) {
        LINES.add(line);
    }
}

ReceiptThread thread = new ReceiptThread("A7");
thread.start();
thread.join();
String line = ReceiptLog.LINES.getLast();         // "A7 sent by receipt-A7"

The Thread class itself implements Runnable. Its own run() method calls the Runnable passed to the constructor, or does nothing if there is none, which is why a subclass must override run() to do any work.

2. Runnable Interface

A class implements Runnable when its instances are meant to be executed by a thread. The interface has one method, void run(), with no parameters, no return value and no checked exceptions. Since Java 8, Runnable is annotated as a functional interface, so a lambda or a method reference can implement it.

class SendReceiptTask implements Runnable {
    private final String orderId;

    SendReceiptTask(String orderId) {
        this.orderId = orderId;
    }

    @Override
    public void run() {
        ReceiptLog.record(orderId + " sent by " + Thread.currentThread().getName());
    }
}

To run the task on a new thread, we create a Thread, pass the task to the constructor and call start(). The same object also works with an executor or a virtual thread, because they all accept a Runnable.

Thread platform = new Thread(new SendReceiptTask("B2"), "mailer");
platform.start();
platform.join();
String first = ReceiptLog.LINES.getLast();        // "B2 sent by mailer"

Thread virtual = Thread.ofVirtual().name("vmail").start(new SendReceiptTask("C3"));
virtual.join();
String second = ReceiptLog.LINES.getLast();       // "C3 sent by vmail"

For tasks that must return a value or throw a checked exception, Java offers Callable instead, which is compared in Runnable vs Callable.

3. Difference between Runnable vs. Thread

The core difference is inheritance against composition. A Thread subclass is a thread, so the task and the execution mechanism are one object. A Runnable is only the task, and a separate Thread or executor runs it, so each part can change on its own.

In day-to-day code, the differences show up in inheritance, lambda support, reuse of one instance and how well the task fits executors and virtual threads.

Feature	Runnable	Thread
Type	Functional interface in java.lang	Class in java.lang that implements Runnable
Inheritance	The task class can still extend another class	The subclass cannot extend any other class
Lambda support	Yes, () -> work()	No, a subclass needs a class body
Reuse of one instance	One instance can run on many threads, one after another or at the same time	One instance can be started only once
Executors and virtual threads	Accepted by ExecutorService, CompletableFuture.runAsync() and Thread.ofVirtual()	Only as a plain Runnable, so its thread features are wasted
Thread control (name, priority, daemon)	Set on the Thread or builder that runs the task	Set on the subclass instance itself
Memory	The task object plus a Thread object to run it	One object that is both, so no real saving

The old claim that Runnable saves memory because no thread object is created is wrong. A task always needs a Thread to run on. The real costs are the operating system thread behind each platform thread and its stack, which are the same in both styles.

3.1. Sharing One Task Between Threads

Because a Runnable is separate from the thread, several threads can run the same instance. Any state in the task is shared by all of them, so it must be thread-safe, for example an AtomicInteger instead of an int field.

class PageViewCounter implements Runnable {
    final AtomicInteger views = new AtomicInteger();

    @Override
    public void run() {
        views.incrementAndGet();
    }
}

PageViewCounter counter = new PageViewCounter();
List<Thread> threads = List.of(new Thread(counter), new Thread(counter), new Thread(counter));
for (Thread t : threads) {
    t.start();
}
for (Thread t : threads) {
    t.join();
}
int views = counter.views.get();                  // 3, one shared task

With a Thread subclass, each started thread is a new instance with its own fields. Sharing state is still possible through a static field or a shared object, but it no longer follows from the design.

3.2. Moving a Task to an Executor or Virtual Thread

Production code runs tasks on an ExecutorService so threads are reused or, with virtual threads, created cheaply per task. A Runnable moves there without any change.

int before = ReceiptLog.LINES.size();
try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
    executor.submit(new SendReceiptTask("D4"));
    executor.submit(new SendReceiptTask("E5"));
}                                                 // close() waits for both tasks
int added = ReceiptLog.LINES.size() - before;     // 2

A Thread subclass can be submitted too, because it is a Runnable, but the executor calls only its run() method on a pool thread. The subclass object is never started, so its name, priority and daemon settings are ignored, which confuses readers of the code and of the logs.

4. When Extending Thread Still Makes Sense

Extending Thread is reasonable only when the class changes thread behavior rather than describing a task. The JDK does it in ForkJoinWorkerThread, and frameworks subclass it to attach per-thread resources or to clean up in run() after the task completes.

Even in those cases, the subclass is created by a ThreadFactory and runs tasks given to it, so application code still writes Runnable tasks. For one-off threads, the Thread builders added in Java 21 set the name, daemon flag and priority without a subclass.

5. Sending Receipts After Checkout

An online shop saves the order and must send a receipt email, but the customer should not wait for the mail server. The checkout code hands a SendReceiptTask to an executor and returns. Because the task is a plain Runnable, a unit test calls run() on the test thread and checks the result without starting any thread.

SendReceiptTask task = new SendReceiptTask("F6");
task.run();                                       // runs on the calling thread
String inTest = ReceiptLog.LINES.getLast();       // "F6 sent by main"

When the shop later moves from a fixed thread pool to virtual threads, only the line that creates the executor changes. A ReceiptThread subclass would need its callers rewritten, since every call site creates and starts a new thread object. The broader picture of executors, locks and concurrent collections is in the Java concurrency guide.

6. Runnable vs Thread FAQs

Mixing both styles in one codebase raises a few practical doubts, mostly about inheritance, run() and passing one Thread to another.

6.1. Is it better to implement Runnable or extend Thread?

Implement Runnable. It keeps the class free to extend another class, works with lambdas, executors and virtual threads, and can be tested without starting a thread. Extend Thread only when the class customizes the thread itself.

6.2. Why does the Thread class implement Runnable?

So that a Thread has a run() method to call after start(). The default Thread.run() calls the Runnable passed to the constructor, which is how new Thread(task) works, and a subclass replaces it with its own code.

6.3. What happens if we call run() instead of start()?

The task runs on the current thread like an ordinary method call, and no new thread is created. Only start() runs run() concurrently.

6.4. Can a class extend Thread and implement Runnable at the same time?

Yes, it compiles, but it adds nothing, because Thread already implements Runnable. Such a class still has every drawback of a Thread subclass.

6.5. Can we pass a Thread object to another Thread’s constructor?

Yes, because a Thread is a Runnable. The new thread calls the inner object’s run() method, while the inner thread is never started, which makes the code misleading. Pass a Runnable instead.

7. Conclusion

Implementing Runnable is the preferred way. We are not specializing or modifying the thread’s behavior, we are giving the thread something to run, so composition fits better than inheritance.

A Runnable task moves between a plain Thread, a pool, CompletableFuture and virtual threads without a change, and it can be tested on the calling thread. Extending Thread remains for the few classes that change how threads themselves work.

8. References

• Runnable (Java SE 25 API)
• Thread (Java SE 25 API)
• ExecutorService (Java SE 25 API)
• JEP 444, Virtual Threads

Happy Learning !!

Source Code on Github