当使用2个不同的线程打印奇数偶数时，animalMonitorException

Question

Following is my code to print odd even number using 2 different threads. But while running the code, i am getting IllegalMonitorException.

Please help me to understand why I am getting this exception.

class PrintOddEven {

    public static void main(String args[]) {
        Integer num = new Integer(1);
        Thread odd = new Thread(new Odd(num));
        Thread even = new Thread(new Even(num));
        odd.start();
        even.start();
    }
}

class Odd implements Runnable {
    Integer num;

    public Odd(Integer num) {
        super();
        this.num = num;
    }

    @Override
    public void run() {
        while (num <= 100) {
            try {
                synchronized (num) {
                    if (num % 2 == 0) {
                        num.wait();
                    }
                    System.out.println(num);
                    num++;
                    num.notifyAll();
                    num.wait();

                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

class Even implements Runnable {

    Integer num;

    public Even(Integer num) {
        super();
        this.num = num;
    }

    @Override
    public void run() {
        while (num <= 100) {
            try {
                synchronized (num) {
                    if (num % 2 != 0) {
                        num.wait();
                    }
                    System.out.println(num);
                    num++;
                    num.notifyAll();
                    num.wait();
                }

            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

Please help me to understand why this code is throwing illegalMonitorException

Answer 1

    Integer num = new Integer(1);
    System.out.println(num.hashCode());
    num++;
    System.out.println(num.hashCode());

If you execute this piece of code then you will find hashcode is different (which is their value ie 1 and 2) so if hashcode is different then how could it be same object (as pointed out by @Nathan Hughes). So that is the reason you're getting java.lang.IllegalMonitorStateException

import java.util.concurrent.atomic.AtomicInteger;

class PrintOddEven {

    public static void main(String args[]) {
        AtomicInteger num = new AtomicInteger(1);
        Thread odd = new Thread(new Odd(num));
        Thread even = new Thread(new Even(num));
        odd.start();
        even.start();
    }
}

class Odd implements Runnable {
    AtomicInteger num;

    public Odd(AtomicInteger num) {
        super();
        this.num = num;
    }

    @Override
    public void run() {
        while (num.get() < 100) {
            try {
                synchronized (num) {
                    if (num.get() % 2 == 0) {
                        num.wait();
                    }
                    System.out.println(num);
                    num.getAndIncrement();
                    num.notifyAll();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

class Even implements Runnable {

    AtomicInteger num;

    public Even(AtomicInteger num) {
        super();
        this.num = num;
    }

    @Override
    public void run() {
        while (num.get() <= 100) {
            try {
                synchronized (num) {
                    if (num.get() % 2 != 0) {
                        num.wait();
                    }
                    System.out.println(num);
                    num.getAndIncrement();
                    num.notifyAll();
                }

            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

Answer 2

Integer objects are immutable. When you change its value you're replacing the object being referenced by the variable with a new instance. A thread acquires the lock on the object referenced by num, then increments the number, thereby replacing the object with another one. Then the thread calls notifyAll on the object referenced by num, which is a different object from the one that it acquired the lock on. You're not allowed to do that, that's what the IllegalMonitorStateException is telling you.

TLDR: the lock isn't on a variable, it's on an object. Incrementing the value of an immutable object swaps that object out for a different object where nothing has acquired its lock.

Use a dedicated lock that you don't use for anything else, and pass that to your Odd and Even objects.