Java SynchronizedCounter无法按预期工作

Question

I have a class

class SynchronizedCounter {
    private int i = 0;

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

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

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

which is used like that:

public class CounterTest {
    public static void main(String[] args) throws InterruptedException {
        SynchronizedCounter c = new SynchronizedCounter();
        Thread d = new Thread(new D(c));
        Thread e = new Thread(new E(c));
        d.start();
        e.start();
        System.out.println(c.getValue());           
    }
}

where class D is implemented as follows:

class D implements Runnable {
    private SynchronizedCounter counter;

    D(SynchronizedCounter counter) {
        this.counter = counter;
    }

    @Override
    public void run() {
        counter.increment();
    }
}

Class E has only one different line in comparison to the class D

 counter.decrement();

in it's run method.

I would expect to have always 0 printed because the methods of the SynchronisedCounter class are all synchronised, however I get 1 sometimes. Could you explain me please what is wrong with this code? When I run d.start() and e.start() in synchronized(c) block then it works as expected, the same happens when I add d.join() after d.start() and e.join() after e.start().

Answer 1

You're making a lot of assumptions about threads which do not hold true. The two main assumptions of yours which do not hold true are these:

• All threads run at the same speed.
• All threads are started immediately.

The execution sequence is random. The threads run concurrently. In the following, sequence means the sequence in which the threads hit SynchronizedCounter via the method calls. Because that's what synchronized does, it forces concurrent threads into sequential access by guarding it with a monitor (if you don't know what a monitor is, read mutex semaphore instead, it's different, but for this explanation the difference isn't important). You can expect any of the following three outputs:

• 0 in case the sequence was D, E, main; or E, D, main; or main, D, E; or main, E, D.
• 1 in case the sequence was D, main, E
• -1 in case the sequence was E, main, D.

Threads are not started immediately

When you invoke new Thread().start() , the Thread becomes runnable. But it is up to the scheduler to decide when the thread actually gets CPU time. And that depends on factors outside the realm of a program's influence, sometimes even outside the realm of a VM's influence. For example, how close any of the existing threads is to being preempted because of exhausting its timeslice, or whether idle CPU cores are available right now.

Threads run at different speeds

The speed of a thread is determined by various factors which are outside the realm of a program's influence. For example, if the thread wants to access data, whether that data is cached or not, and in which cache it is, to give just one example.

The output -1 is the most unlikely output, but even that output cannot be ruled out completely. And that "unlikely" is also purely based on assumptions made from observations of how virtual machines usually behave, and it is not anything that can be relied upon.