Java - Multithreading: A Beginner's Guide

Hello there, aspiring Java programmers! Today, we're going to embark on an exciting journey into the world of Java multithreading. Don't worry if you're new to programming – I'll be your friendly guide, and we'll tackle this topic step by step. So, grab a cup of coffee (or tea, if that's your thing), and let's dive in!

What is Multithreading?

Imagine you're in a kitchen, trying to prepare a complex meal. You could do everything one at a time – chop the vegetables, then boil the pasta, then prepare the sauce. But wouldn't it be more efficient if you could do all these tasks simultaneously? That's exactly what multithreading allows our programs to do!

In simple terms, multithreading is a feature that allows a program to perform multiple tasks concurrently. Each of these tasks is called a "thread," and they run independently but can share resources when needed.

Why Use Multithreading?

You might be wondering, "Why should I bother with multithreading?" Well, let me tell you a little story.

Back when I first started programming, I created a simple application to download multiple files from the internet. It worked fine, but it was painfully slow because it downloaded one file at a time. Then I learned about multithreading, applied it to my program, and voila! It was like upgrading from a bicycle to a sports car. The files downloaded simultaneously, and the overall process was much faster.

Multithreading can:

1. Improve performance and efficiency
2. Allow better resource utilization
3. Enhance user experience in GUI applications
4. Enable asynchronous operations

The Life Cycle of a Thread

Before we start coding, let's understand the life cycle of a thread. It's like the life of a butterfly, but with more coding and less flying!

1. New: The thread is created but not yet started.
2. Runnable: The thread is ready to run and waiting for CPU time.
3. Running: The thread is executing its task.
4. Blocked/Waiting: The thread is temporarily inactive (e.g., waiting for I/O or another thread).
5. Terminated: The thread has completed its task and is dead.

Now, let's see how we can create and use threads in Java.

Creating Threads in Java

There are two main ways to create threads in Java:

1. Implementing the Runnable Interface

This is often considered the better approach because it doesn't require us to extend the Thread class, allowing our class to extend other classes if needed.

public class MyRunnable implements Runnable {
    public void run() {
        System.out.println("Thread is running!");
    }

    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable);
        thread.start();
    }
}

In this example:

• We create a class MyRunnable that implements the Runnable interface.
• We override the run() method, which defines what the thread will do.
• In the main method, we create an instance of MyRunnable and pass it to a new Thread object.
• We call the start() method to begin execution of the thread.

2. Extending the Thread Class

This approach is straightforward but less flexible.

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

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

Here:

• We create a class MyThread that extends the Thread class.
• We override the run() method.
• In the main method, we create an instance of MyThread and call its start() method.

Thread Priorities

Just like in a classroom where some students get called on more often than others (not that I ever played favorites!), threads can have different priorities. The priority ranges from 1 (lowest) to 10 (highest), with 5 being the default.

public class PriorityDemo {
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> System.out.println("I'm thread 1"));
        Thread t2 = new Thread(() -> System.out.println("I'm thread 2"));

        t1.setPriority(Thread.MIN_PRIORITY); // Priority 1
        t2.setPriority(Thread.MAX_PRIORITY); // Priority 10

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

In this example, t2 has a higher priority, so it's more likely to run before t1. However, remember that thread scheduling can be unpredictable, so don't rely too heavily on priorities!

Important Thread Methods

Let's look at some important methods of the Thread class:

Method	Description
start()	Starts the thread, calling the run() method
run()	Contains the code that defines the thread's task
sleep(long millis)	Pauses the thread for a specified number of milliseconds
join()	Waits for the thread to die
isAlive()	Tests if the thread is alive
interrupt()	Interrupts the thread

Here's a simple example using some of these methods:

public class ThreadMethodsDemo {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                System.out.println("Thread is working: " + i);
                try {
                    Thread.sleep(1000); // Sleep for 1 second
                } catch (InterruptedException e) {
                    System.out.println("Thread was interrupted!");
                    return;
                }
            }
        });

        thread.start();
        System.out.println("Thread is alive: " + thread.isAlive());

        Thread.sleep(3000); // Main thread sleeps for 3 seconds
        thread.interrupt(); // Interrupt the thread

        thread.join(); // Wait for the thread to finish
        System.out.println("Thread is alive: " + thread.isAlive());
    }
}

This example demonstrates starting a thread, checking if it's alive, sleeping, interrupting, and joining threads.

Major Java Multithreading Concepts

Now that we've covered the basics, let's briefly touch on some advanced multithreading concepts:

1. Synchronization: Ensures that only one thread can access a shared resource at a time.
2. Deadlock: A situation where two or more threads are unable to proceed because each is waiting for the other to release a lock.
3. Thread Pool: A group of worker threads that are waiting for tasks and can be reused multiple times.
4. Concurrent Collections: Thread-safe collections designed for use in multithreaded environments.

These concepts are crucial for writing efficient and bug-free multithreaded applications, but they're topics for another day!

Conclusion

Congratulations! You've taken your first steps into the world of Java multithreading. We've covered the basics of what threads are, how to create them, and some fundamental methods for working with them.

Remember, multithreading is a powerful tool, but it can also introduce complexity and potential bugs if not used carefully. As you continue your Java journey, keep practicing and exploring more advanced multithreading concepts.

Happy coding, and may your threads always run smoothly!

Credits: Image by storyset