What Is a Thread in Java — Thread, Runnable, and Multithreading Explained

A thread is an independent execution path inside one JVM process.

What's isolated per thread

• Stack (local variables, call frames)
• Program counter
• ThreadLocal values

What's shared

• The heap — all objects allocated with new
• Method area, loaded classes, static fields
• File descriptors and system resources

This shared-heap model is the core of both power and danger

• Power: passing data between threads is free — share an object reference
• Danger: uncoordinated reads and writes cause race conditions and visibility bugs

On mainstream JVMs, platform threads are 1:1 with OS threads

• pthread_create on Linux, CreateThread on Windows
• ~512 KB to 1 MB of stack per thread (tunable with -Xss)
• Practical limit: 5,000–10,000 platform threads per server
• The OS scheduler, not the JVM, decides when each runs

Three ways to create threads

• Extend `Thread` — legacy; wastes single inheritance slot
• Implement `Runnable` — preferred; functional interface so lambdas work; decouples task from thread
• `ExecutorService` — the modern default; submit Runnable or Callable tasks to a pool
• `Callable` is Runnable plus return value and checked-exception support

When multithreading actually helps

• CPU-bound parallelism — dividing work across cores (up to Amdahl's limit)
• I/O concurrency — overlapping slow network or disk waits
• Responsiveness — keeping UI or event loops free while background work runs

Java 21 virtual threads changed everything for I/O workloads

• M:N scheduled — JVM multiplexes millions of virtual threads on a small platform-thread carrier pool
• When a virtual thread blocks on I/O, it unmounts from its carrier cheaply
• Executors.newVirtualThreadPerTaskExecutor() is the idiom
• Use for I/O-bound servers; avoid for CPU-bound work or code with synchronized on long I/O (pinning problem)

Recommendation: In modern code, don't call new Thread(...) directly. Reach for ExecutorService for bounded pools on CPU work, or Executors.newVirtualThreadPerTaskExecutor() on Java 21+ for I/O-bound request handling. Always prefer Runnable or Callable over extending Thread. Remember that the heap is shared — any mutable state accessed from multiple threads needs coordination via synchronized, java.util.concurrent, or immutability.