Creating Threads: Thread Class vs Runnable

Java gives you two standard ways to define the code a thread should run: extending the Thread class and overriding run(), or implementing the Runnable interface and passing it to a Thread. Both approaches ultimately start a new thread the same way — by calling start() — but they differ in flexibility and design implications.

Why it matters

There are two ways to define what a thread does, and one mistake that makes neither of them work: calling run() instead of start(). The code runs, prints the right thing, and no second thread was ever created. Knowing the difference, and why Runnable is preferred, is basic to every later topic in concurrency.

Approach 1: Extending Thread

You create a subclass of Thread and override its run() method with the code you want executed concurrently. You then instantiate your subclass and call start() on it. This works, but it consumes your one allowed superclass in Java — since Java does not support multiple inheritance of classes, a class that extends Thread cannot extend anything else.

Approach 2: Implementing Runnable (Preferred)

You create a class that implements Runnable and defines its single abstract method, run(). You then wrap an instance of that class in a new Thread(runnableInstance) and call start() on the Thread object. This is generally the preferred approach because your task class remains free to extend some other class if needed, it cleanly separates "the task to run" from "the mechanism that runs it," and it works naturally with the Executor framework, which expects Runnable (or Callable) tasks rather than Thread subclasses.

• Extends Thread: simpler for a one-off, but uses up your single inheritance slot.
• Implements Runnable: more flexible, reusable across multiple Thread objects, and the idiomatic choice in modern Java code, including with lambdas.

start() vs run() — The Most Important Distinction

Calling start() asks the JVM to create a new call stack and a new native OS thread, which will eventually invoke run() on that new thread. Calling run() directly, by contrast, is just an ordinary method call — it executes on the current thread, synchronously, with no concurrency at all. This is one of the most common beginner mistakes: the code compiles and even produces output, but nothing actually runs concurrently.

Example

class CounterThread extends Thread {
    @Override
    public void run() {
        System.out.println("CounterThread running on: " + Thread.currentThread().getName());
    }
}

class CounterTask implements Runnable {
    @Override
    public void run() {
        System.out.println("CounterTask running on: " + Thread.currentThread().getName());
    }
}

public class ThreadCreationDemo {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new CounterThread();
        t1.setName("Worker-Extends");
        t1.start();
        t1.join();

        Thread t2 = new Thread(new CounterTask(), "Worker-Runnable");
        t2.start();
        t2.join();

        // run() called directly: executes on main, NOT a new thread
        new CounterTask().run();
    }
}

CounterThread running on: Worker-Extends
CounterTask running on: Worker-Runnable
CounterTask running on: main

Exercise

Create a thread from a Runnable written as a lambda. The thread prints worker running. The main thread waits for it and then prints main done.

Expected output: worker running then main done

public class FirstThread {
    public static void main(String[] args) throws InterruptedException {
        // TODO: create a Runnable that prints "worker running"
        // TODO: create a Thread for it, start it, and wait for it to finish

        System.out.println("main done");
    }
}

public class FirstThread {
    public static void main(String[] args) throws InterruptedException {
        Runnable task = () -> System.out.println("worker running");
        Thread worker = new Thread(task);
        worker.start();
        worker.join();

        System.out.println("main done");
    }
}

Quick quiz

Interview questions