How Can Java Developers Become Better at Multithreading?

Multithreading can be complex and challenging at times. We see engineers struggling to use it to its full potential.

By definition, Multithreading is the process of executing two or more threads in a program concurrently. Java has supported Multithreading since version 1.0.

Example Code of creating a Thread

public class MyThread extends Thread {
    public void run() {
        System.out.println("Thread is running...");
    }

    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        t1.start();
    }
}

Why Is Multithreading hard?

Multithreading involves several concepts that can be challenging to grasp.

• Concurrency: Multiple things are happening at the same time.
• Synchronization: To ensure data integrity between threads.
• Coordination: Ordering and dependency management between threads.
• Visibility: This ensures that one thread sees changes made by others.

Thread LifeCycle

State	Description	Transition To	Triggered By / Example
New	Thread is created but not yet started.	Runnable	Thread t = new Thread();
Runnable	Thread is ready to run and waiting for CPU time.	Running	t.start();
Running	Thread is currently executing its run() method.	Waiting / Timed Waiting / Terminated	OS scheduler picks the thread
Blocked	Thread is waiting to enter a synchronized block locked by another thread.	Runnable	Enters locked code section (e.g., synchronized block)
Waiting	Thread is waiting indefinitely for another thread to perform a specific action.	Runnable	wait(), join() without timeout, LockSupport.park()
Timed Waiting	Thread is waiting for another thread or time to expire.	Runnable	sleep(ms), join(ms), wait(ms)
Terminated (Dead)	Thread has completed execution or was aborted.	No transition (End state)	run() method finishes or exception occurs

Below diagram shows the Lifecylcle Transitions of a Thread.

New ──▶ Runnable ──▶ Running ──▶ Terminated
                │       │
                ▼       ▼
           Blocked   Waiting/Timed Waiting
                ▲       │
                └───────┘

Let us understand with a simple code some of these LifeCycle steps.

public class ThreadLifecycleExample {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            System.out.println("Thread is running...");
        });

        System.out.println("State after creation: " + t.getState()); // NEW
        t.start();
        System.out.println("State after start: " + t.getState());    // RUNNABLE

        t.join(); // Wait for thread to die
        System.out.println("State after completion: " + t.getState()); // TERMINATED
    }
}

Race Conditions and Data Inconsistency

We say a race condition has occurred when two or more threads access the shared data and attempt to modify it simultaneously.

Consider the code below:

class Counter {
    int count = 0;

    public void increment() {
        count++;
    }
}

Now, if two threads call the above method simultaneously, the count may increase incorrectly.

How to fix this? We can make this method synchronised so that only one thread can access it at a time.

public synchronized void increment() {
    count++;
}

Should we use synchronisation everywhere in a multi-threaded application? Answer is NO.

Overusing or incorrectly using this keyword can lead to:

• Performance bottlenecks
• Deadlocks
• Thread Starvation

Debugging Tools

Bugs related to multithreading can be very hard to reproduce as they are often nondeterministic. In such cases, stack traces might not reveal the real issue. Using tools like a debugger can also be of little help spatially when it comes to race conditions.  However, some tools can give some information:

• VisualVM
• JConsole
• Thread dumps
• Java Flights Recorder

Concepts to master to become better at multithreading

• Thread Lifecycle
• Concurrency Utilities like ExecutorService, Future, CountDownLatch, etc.
• Locking Mechanisms
• Java Memory Model
• Using Tools like VisualVM, JFR, JConsole, etc.

---