Java - Reentrant Monitor

Hello there, future Java wizards! Today, we're going to embark on an exciting journey into the world of Reentrant Monitors in Java. Don't worry if you're new to programming – I'll be your friendly guide, and we'll take this step-by-step. So, grab your virtual wands (keyboards), and let's dive in!

What is a Reentrant Monitor?

Before we get into the nitty-gritty, let's understand what a Reentrant Monitor is. Imagine you're in a magical library where only one person can enter a specific section at a time. Now, what if you're already in that section and need to go deeper into a subsection? A Reentrant Monitor is like a magical pass that allows you to do just that – enter a section you're already in!

In Java terms, a Reentrant Monitor allows a thread that already holds a lock to acquire it again without blocking. It's like giving yourself permission to enter a room you're already in. Neat, right?

Why Do We Need Reentrant Monitors?

You might be wondering, "Why do we need this magical pass?" Well, in the world of multithreading (where multiple parts of a program run simultaneously), we often need to protect shared resources. Reentrant Monitors help us do this more efficiently, especially when we have methods calling other methods that also need the same lock.

Introducing ReentrantLock

Java provides us with a class called ReentrantLock to implement Reentrant Monitors. It's like our magical library pass, but in code form!

Syntax

Here's how we create and use a ReentrantLock:

import java.util.concurrent.locks.ReentrantLock;

ReentrantLock lock = new ReentrantLock();

// To lock
lock.lock();
try {
    // Your protected code here
} finally {
    // To unlock
    lock.unlock();
}

Don't worry if this looks a bit intimidating. We'll break it down with some examples!

Multithreading Without Reentrant Lock

Let's start with a simple example without using ReentrantLock. Imagine we have a magical counter that multiple wizards (threads) are trying to increment:

public class MagicalCounter {
    private int count = 0;

    public void increment() {
        count++;
    }

    public int getCount() {
        return count;
    }
}

Now, let's create some wizard threads to increment this counter:

public class WizardThread extends Thread {
    private MagicalCounter counter;

    public WizardThread(MagicalCounter counter) {
        this.counter = counter;
    }

    public void run() {
        for (int i = 0; i < 1000; i++) {
            counter.increment();
        }
    }
}

public class MagicalCounterTest {
    public static void main(String[] args) throws InterruptedException {
        MagicalCounter counter = new MagicalCounter();
        WizardThread wizard1 = new WizardThread(counter);
        WizardThread wizard2 = new WizardThread(counter);

        wizard1.start();
        wizard2.start();

        wizard1.join();
        wizard2.join();

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

If you run this, you might expect the final count to be 2000 (1000 increments from each wizard). But surprise! The result is often less than 2000. This is because our wizards are stepping on each other's toes – they're trying to increment the counter at the same time, leading to lost increments.

Multithreading With Reentrant Lock

Now, let's sprinkle some ReentrantLock magic on our counter:

import java.util.concurrent.locks.ReentrantLock;

public class MagicalCounterWithLock {
    private int count = 0;
    private ReentrantLock lock = new ReentrantLock();

    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }

    public int getCount() {
        return count;
    }
}

Let's break this down:

1. We create a ReentrantLock object called lock.
2. In the increment method, we call lock.lock() before incrementing the counter.
3. We use a try-finally block to ensure that we always unlock, even if an exception occurs.
4. After incrementing, we call lock.unlock() in the finally block.

Now, if we run our WizardThread test with this new MagicalCounterWithLock, we'll always get 2000 as the final count. Our wizards are now taking turns nicely!

Multithreading With Reentrant Lock as True

ReentrantLock has another trick up its sleeve. We can create it with a fairness parameter:

ReentrantLock fairLock = new ReentrantLock(true);

When we set fairness to true, the lock favors granting access to the longest-waiting thread. It's like forming a proper queue for our wizards!

Here's how we might use it:

public class FairMagicalCounter {
    private int count = 0;
    private ReentrantLock fairLock = new ReentrantLock(true);

    public void increment() {
        fairLock.lock();
        try {
            count++;
        } finally {
            fairLock.unlock();
        }
    }

    public int getCount() {
        return count;
    }
}

This ensures that if multiple wizards are waiting to increment the counter, the one who's been waiting the longest gets to go next.

Conclusion

And there you have it, young wizards! We've journeyed through the magical world of Reentrant Monitors in Java. We've seen how they help us manage shared resources in multithreaded environments, ensuring our magical counters (and other shared objects) are incremented correctly.

Remember, like any powerful magic, Reentrant Monitors should be used wisely. They're great for managing concurrent access to shared resources, but overuse can lead to decreased performance or even deadlocks (a situation where wizards are stuck waiting for each other's locks forever!).

Practice these spells... err, code examples, and soon you'll be casting multithreading magic like a pro! Happy coding, and may your threads always be in harmony!

Credits: Image by storyset