Embedded Prep

Multithreading in Java : When you use applications like web browsers, media players, or even mobile apps, many tasks happen at the same time. You might stream music while scrolling social media or download files while working on documents. Multithreading in Java is a powerful feature that makes this concurrency possible. It allows programs to execute multiple tasks simultaneously, improving speed and responsiveness.

In this article, we’ll explore what multithreading is, why it matters, how it works in Java, and how you can implement it with practical examples.

What is Multithreading?

Multithreading is a programming technique where multiple lightweight sub-processes, known as threads, run within a single program. Each thread operates independently, performing different tasks while sharing the same memory space.

For example, imagine a music player app:

• One thread plays music.
• Another thread listens for user input (like clicking pause).
• A third thread updates the song’s progress bar.

All these tasks run in parallel, making the app smooth and responsive.

Why Use Multithreading in Java?

Here are some benefits of using multithreading in Java:

✅ Better Resource Utilization: Threads share memory and resources, reducing overhead.

✅ Improved Performance: Multithreaded programs can complete tasks faster by utilizing multiple CPU cores.

✅ Responsive Applications: User interfaces remain smooth, even during heavy processing.

✅ Simplified Program Structure: Certain problems are naturally easier to solve with threads, like handling multiple client requests in a server application.

How Java Supports Multithreading

Java makes multithreading simple with built-in support in the java.lang.Thread class and the java.util.concurrent package.

Thread Class

In Java, a thread is represented by the Thread class. You can create threads in two ways:

1. Extending the Thread Class

class MyThread extends Thread {
    public void run() {
        System.out.println("Thread running: " + Thread.currentThread().getName());
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        t1.start(); // starts the thread
        System.out.println("Main method: " + Thread.currentThread().getName());
    }
}

• run() contains the code the thread executes.
• start() launches the new thread.

2. Implementing Runnable Interface

A more flexible way is to implement the Runnable interface:

class MyRunnable implements Runnable {
    public void run() {
        System.out.println("Runnable thread: " + Thread.currentThread().getName());
    }
}

public class Main {
    public static void main(String[] args) {
        Thread t1 = new Thread(new MyRunnable());
        t1.start();
        System.out.println("Main thread: " + Thread.currentThread().getName());
    }
}

✅ Recommended for better flexibility, especially when you want your class to extend another class.

Managing Multiple Threads

Creating many threads is easy, but managing them safely requires care. Here’s what you need to know:

Thread Sleep

Pause a thread for a certain period:

try {
    Thread.sleep(1000); // Sleep for 1 second
} catch (InterruptedException e) {
    e.printStackTrace();
}

Thread Join

Wait for one thread to finish before continuing:

Thread t1 = new Thread(() -> {
    System.out.println("Child thread running");
});

t1.start();

try {
    t1.join();
} catch (InterruptedException e) {
    e.printStackTrace();
}

System.out.println("Main thread resumes after child thread finishes");

Synchronization

Threads often share resources, which can cause race conditions (e.g. two threads updating the same variable at the same time). Synchronization ensures only one thread accesses a block of code at a time:

class Counter {
    private int count = 0;

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

    public int getCount() {
        return count;
    }
}

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();

        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });

        t1.start();
        t2.start();

        t1.join();
        t2.join();

        System.out.println("Final count: " + counter.getCount());
    }
}

Without synchronization, you’d get inconsistent results!

Executors: A Modern Way to Handle Threads

Java introduced the Executor framework in java.util.concurrent for easier thread management.

Example using a thread pool:

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Main {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(3);

        for (int i = 0; i < 5; i++) {
            executor.execute(() -> {
                System.out.println("Running in thread: " + Thread.currentThread().getName());
            });
        }

        executor.shutdown();
    }
}

✅ Benefits of Executors:

• Reuse threads instead of creating new ones every time.
• Control the number of concurrent threads.
• Simpler error handling and shutdown.

Common Multithreading Problems

Despite its power, multithreading comes with pitfalls:

🔴 Deadlock: Two threads wait forever for each other’s resources.

🔴 Race Condition: Threads accessing shared data simultaneously cause unpredictable behavior.

🔴 Starvation: A thread never gets CPU time because others monopolize it.

Always test and synchronize critical code carefully!

Conclusion

Multithreading in Java unlocks significant performance and responsiveness benefits. Whether you’re building desktop apps, web servers, or data-processing tools, mastering threads helps you write scalable, efficient software.

Start small:

• Learn the basics of Thread and Runnable.
• Experiment with synchronization.
• Explore the Executor framework for production-level code.

With practice, you’ll write multithreaded Java applications confidently!