No deadlock while incrementing synchronized Integer objects

Question

I am tried to implement deadlock in my program and all was ok except one issue which I can't explain.

public class Test {
    public static void main(String[] args) throws InterruptedException {
        Integer balanceA = 10000;
        Integer balanceB = 10000;

        Thread t1 = new Thread(() -> {
            while (true) {
                Processor.run(balanceA, balanceB);
            }
        });

        Thread t2 = new Thread(() -> {
            while (true) {
                Processor.run(balanceB, balanceA);
            }
        });

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

class Processor {
    public static void run(Integer balanceA, Integer balanceB) {
        synchronized (balanceA) {
            synchronized (balanceB) {
                System.out.println(balanceA++ + "; " + balanceB--);
            }
        }
    }
}

Why it always show me the same result as if I did't modify Integer values:

10000; 10000

...

because you don't. you first print the (local) variable, and after that, you alter the value. but it's only the local value you alter, so not the value that is being passed the next time — Stultuske, Jan 28 '19 at 07:43

score 1 · Accepted Answer · answered Jan 28 '19 at 07:43

balanceA++ is equivalent to balanceA = balance + 1. It doesn't modify the Integer (it can't, because Integer is immutable). It just changes the value of the balanceA parameter to refer to a different object.

If you use AtomicInteger and call either incrementAndGet or getAndIncrement, then you'll see the values changing. You also won't need any synchronization.

No deadlock while incrementing synchronized Integer objects

1 Answers1