Creating Threads

#Introduction

Java gives you two classic ways to define work for a thread — extend Thread or implement Runnable — plus Callable for tasks that return a value (covered with executors). This chapter covers both, the critical start() vs run() difference, and the thread properties every backend developer should know: names, daemon status, priorities and uncaught-exception handlers.

#Way 1 — Extend Thread

class EmailSender extends Thread {

    @Override
    public void run() {
        System.out.println("Sending email on " + Thread.currentThread().getName());
    }
}

public class Main {
    public static void main(String[] args) {
        EmailSender sender = new EmailSender();
        sender.start();
        System.out.println("Main continues on " + Thread.currentThread().getName());
    }
}

Main continues on main
Sending email on Thread-0

The order of the two lines is not guaranteed — the threads run independently and the scheduler decides.

#Way 2 — Implement Runnable

class EmailTask implements Runnable {

    @Override
    public void run() {
        System.out.println("Sending email on " + Thread.currentThread().getName());
    }
}

Thread thread = new Thread(new EmailTask());
thread.start();

Runnable is a functional interface (void run()), so a lambda works too:

Thread thread = new Thread(() -> System.out.println("Sending email"));
thread.start();

Java 21 Builders

Thread t1 = Thread.ofPlatform().name("email-sender").start(() -> sendEmail());
Thread t2 = Thread.ofVirtual().start(() -> sendEmail());   // a virtual thread

#Thread vs Runnable — Which to Use?

#Naming Threads

Default names like Thread-0 make logs and thread dumps useless. Name your threads:

Thread worker = new Thread(task, "invoice-generator");
worker.setName("invoice-generator-1");

In production, name pool threads with a ThreadFactory (covered with ThreadPoolExecutor) — e.g. order-processor-1, order-processor-2.

#Daemon Threads

A daemon thread is a background thread that doesn't keep the JVM alive. When only daemon threads remain, the JVM exits — abruptly stopping them.

Thread heartbeat = new Thread(() -> {
    while (true) {
        System.out.println("heartbeat");
        sleepQuietly(1000);
    }
});
heartbeat.setDaemon(true);   // must be set BEFORE start()
heartbeat.start();

#Thread Priorities

thread.setPriority(Thread.MAX_PRIORITY);   // 10; MIN_PRIORITY = 1, NORM_PRIORITY = 5

Priorities are only a hint to the OS scheduler — many platforms largely ignore them. Never rely on priorities for correctness or ordering.

#Exceptions in Threads

An exception thrown in another thread does not propagate to the thread that started it:

try {
    new Thread(() -> { throw new IllegalStateException("boom"); }).start();
} catch (Exception e) {
    System.out.println("Never printed");   // the exception happens on another thread
}

Exception in thread "Thread-0" java.lang.IllegalStateException: boom

The uncaught exception terminates only that thread and is printed to System.err. Install a handler to log it properly:

Thread worker = new Thread(task, "report-worker");
worker.setUncaughtExceptionHandler((t, e) ->
        log.error("Thread {} failed", t.getName(), e));
worker.start();

// Or a JVM-wide default
Thread.setDefaultUncaughtExceptionHandler((t, e) -> log.error("Uncaught in {}", t.getName(), e));

#Runnable vs Callable — a Preview

Callable and Future are covered in the Executor Framework chapter.

#Why Not Create Threads Manually in Production?

// Anti-pattern: one new thread per request
@PostMapping("/orders")
public void create(@RequestBody Order order) {
    new Thread(() -> process(order)).start();
}

• Under load this creates unbounded threads and can exhaust memory (OutOfMemoryError: unable to create native thread).
• Thread creation cost is paid on every request.
• There's no way to limit, queue, monitor or shut down the work.
• Exceptions disappear into System.err.

Use an ExecutorService (or Spring's @Async with a configured pool) instead — or, on Java 21, virtual threads.

#Key Takeaways

• Define work with Runnable (or Callable), not by extending Thread.
• start() creates a new thread; run() is a plain method call.
• A thread can be started only once.
• Daemon threads don't keep the JVM alive and can die mid-work.
• Exceptions in a thread don't reach the caller — handle or log them explicitly.
• Production code uses executors or virtual threads instead of manual new Thread().