Introduction to Multithreading

#Introduction

Every Java backend is multithreaded, whether you write a single new Thread() or not. Tomcat serves each HTTP request on a worker thread, HikariCP hands out connections to many threads at once, @Async and @Scheduled run on thread pools, and the JVM itself runs garbage-collector and JIT-compiler threads alongside your code.

This topic goes from the basics — what a thread is and how to start one — through synchronization, the Java Memory Model, locks, atomics, executors, CompletableFuture, concurrent collections and virtual threads, to Spring's @Async and classic coding scenarios.

#Program, Process and Thread

What Threads Share — and What They Don't

#Process vs Thread

#Why Use Multiple Threads?

• Responsiveness — a server can keep accepting requests while others are being processed.
• Throughput — while one thread waits for the database or a remote API, others use the CPU.
• Using multiple cores — CPU-heavy work (image processing, report generation) can be split across cores.
• Background work — sending emails, cleaning caches and polling queues without blocking users.

#Concurrency vs Parallelism

A favourite interview question.

A web server handling 200 requests on 8 cores is doing both: the requests are concurrent, and up to 8 of them execute in parallel at any instant.

#I/O-Bound vs CPU-Bound Work

How many threads help depends on what the threads do.

#The Main Thread

Every Java program starts with one non-daemon thread called main:

public class Main {
    public static void main(String[] args) {
        Thread current = Thread.currentThread();
        System.out.println(current.getName());   // main
        System.out.println(current.getId());     // usually 1
        System.out.println(Runtime.getRuntime().availableProcessors() + " cores");
    }
}

main
1
8 cores

The JVM exits when all non-daemon threads have finished — not when main returns. (getId() is deprecated since Java 19 in favour of threadId().)

#The Costs and Risks of Threads

Threads aren't free:

And they introduce whole new categories of bugs:

#How Java Supports Concurrency

Modern code rarely creates raw threads. It submits tasks to executors, coordinates with CompletableFuture and concurrency utilities, and — for high-concurrency I/O — uses virtual threads.

#Key Takeaways

• A process has its own memory; threads inside it share the heap and static data but have their own stacks.
• Concurrency is about structure (overlapping tasks); parallelism is about simultaneous execution on multiple cores.
• I/O-bound work benefits from many threads; CPU-bound work from about one thread per core.
• The JVM exits when all non-daemon threads finish.
• Threads bring race conditions, visibility problems, deadlocks and starvation — the rest of this topic is about preventing them.