Question about synchronization

[Adrian Cordoba]

Hi, all!
I've been studying concurrent programming from Oracle Documentation. And I was testing some code from that tutorial:
I have a class with a field that can be incremented or decremented:

public class Counter {
    private int value;

    public void increment() {
        value++;
    }

    public void decrement() {
        value--;
    }

    public int getValue() {
        return value;
    }
}

And two Thread classes for create threads: One of them for increment the Counter's value, and the other one for decrement it:

public class IncrementThread extends Thread {
    Counter counter;

    public IncrementThread(Counter counter) {
        this.counter = counter;
        setName("Increment thread");
    }

    public void run() {
        while (true) {
            counter.increment();
            System.out.println(this.getName() + ": value = " + counter.getValue());
        }
    }
}

public class DecrementThread extends Thread {
    Counter counter;

    public DecrementThread(Counter counter) {
        this.counter = counter;
        setName("Decrement thread");
    }

    public void run() {
        while (true) {
            counter.decrement();
            System.out.println(this.getName() + ": value = " + counter.getValue());
        }
    }
}

Finally, I coded a main class that creates two threads (IncrementThread and DecrementThread) with the same Counter object, and start them:

public class Program {
    public static void main(String[] args) {
        Counter counter = new Counter();
        
        new IncrementThread(counter).start();
        new DecrementThread(counter).start();
    }
}

I understand when I run this little application that the printed values in console are not consistent:

Decrement thread: value = 8385
Increment thread: value = 8388
Increment thread: value = 8385
Increment thread: value = 8386
Increment thread: value = 8387
Decrement thread: value = 8384
Increment thread: value = 8388

But, what I cannot understand is that something similar happens when I synchronize the access methods to the field "value" of the Counter class (Synchronized Methods):

public class Counter {
    private int value;

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

    public synchronized void decrement() {
        value--;
    }

    public synchronized int getValue() {
        return value;
    }
}

With synchronized methods I get the same thing:

Decrement thread: value = 1989
Decrement thread: value = 1988
Decrement thread: value = 1987
Decrement thread: value = 1986
Increment thread: value = 1990
Decrement thread: value = 1985
Decrement thread: value = 1985
Decrement thread: value = 1984

Can someone tell me what's happening?
(Details are welcome.)

Thank you, in advance.

[Ulf Dittmer]

You seem to assume that lines 11 and 12 of the DecrementThread and IncrementThread are executed atomically, but they're not. It's perfectly possible (likely, in fact), that threads are switched between lines 11 and 12.

[Adrian Cordoba]

Ulf Dittmer wrote:You seem to assume that lines 11 and 12 of the DecrementThread and IncrementThread are executed atomically, but they're not. It's perfectly possible (likely, in fact), that threads are switched between lines 11 and 12.

Thank you, Ulf Dittmer.
Now, I understand.

[Andrew Suckerman]

I don't understand. Can anyone explain details please?