Multithreading and Concurrency Basics

If you’ve ever waited for a file to download while your app completely froze up, you’ve seen a lack of multithreading in action. In this chapter, we’ll explore how Java lets us build programs that do multiple things at once — which is critical for modern software.

Why Concurrency Matters

Most real-world applications need to handle more than one task at a time:

• x>A game listening for keyboard input while updating the screen
• x>A server handling thousands of user requests simultaneously
• x>An app downloading data while still allowing user interaction

Without concurrency, these programs would be stuck doing one thing at a time — painfully slow and frustrating.

What is a Thread?

A thread is the smallest unit of execution in a program.

• x>Every Java program has at least one thread: the main thread.
• x>You can create additional threads to run tasks concurrently.

Think of threads as cooks in a kitchen:

• x>One cook (main thread) makes the salad
• x>Another starts the oven
• x>A third boils water

They work in parallel to finish the meal faster.

Creating Threads in Java

There are multiple ways to create threads, but here are the most common:

Option 1: Extending Thread

Option 2: Implementing Runnable

Option 3: Lambda with Runnable

The Lifecycle of a Thread

Threads in Java go through several states:

• x>New — Thread is created but not started
• x>Runnable — Ready to run
• x>Running — Actually executing
• x>Blocked/Waiting — Paused, waiting for resources or signal
• x>Terminated — Done

This helps the JVM manage resources and ensure threads don’t step on each other.

Thread Safety and Race Conditions

Running things in parallel brings danger: race conditions. Imagine two threads updating the same variable:

They might both read the same value and overwrite each other. That’s bad. Use synchronization to prevent this:

Or better yet, use atomic classes like AtomicInteger.

Executors and Thread Pools

Creating too many threads is inefficient. Java provides Executors to manage a pool of threads:

This lets you reuse threads efficiently without flooding the system

What’s Next

Now that you understand how to do many things at once, it’s time to zoom out and structure your code like a pro. Up next: Design Patterns and SOLID Principles — the mindset and techniques that make your code scalable, flexible, and maintainable in large systems. Let’s level up your software design brain.