方法何时应声明为同步？

Question

Following is a, simple, working program which uses two threads to print a counter:

public class SynchronizedCounter implements Runnable {

    private static int i = 0;

    public void increment() { i++; }
    public int getValue() { return i; }  

    @Override
    public void run() {
        for( int i = 0; i < 5; i++ ) {
            synchronized( this ) {
                increment();
                System.out.println( Thread.currentThread().getName() + " counter: " + this.getValue() );
            }
        }
    }

    public static void main( String[] args ) {

        ExecutorService executorService = Executors.newFixedThreadPool( 2 );
        SynchronizedCounter synchronizedCounter = new SynchronizedCounter();
        executorService.submit( synchronizedCounter );
        executorService.submit( synchronizedCounter );  
        executorService.shutdown();

    }

}

The output is as expected - the two threads display counter in order.

If increment() and getValue() are declared as synchronized and synchronized block code is commented, the output manifests visibility and race problems.

As increment() and getValue() are not declared as synchronized and by, just, using a synchronized block(passing a monitor object) if synchronization could be achieved, in what circumstances should they be declared as synchronized ?

Answer 1

Declare a method synchronized when you need the semantics of a synchronized block around the body of the method.

synchronized void increment() {
  ...
}

is exactly the same as:

void increment() {
  synchronized (this) { ... }
}

The thing about doing that in the code above is that you no longer execute the increment() and getValue() methods atomically: another thread can nip in and execute the methods in between the calls of your thread:

Thread 1             Thread 2

increment()
                     increment()
                     getValue()
getValue()

This is possible, but two threads can't execute increment() (or getValue() ) at the same time, because they are synchronized (*).

On the other hand, synchronizing around the calls as in the code in the question means that the two calls are executed atomically, so the two threads can't interleave:

Thread 1             Thread 2

increment()
getValue()
                     increment()
                     getValue()

---

(*) Actually, they can both be executing the method at the same time. It's just that all but one of the threads will be waiting at the synchronized (this) .

Answer 2

In your code, the class itself is not thread safe and it is up to the client (your run method) to ensure thread safety.

If you want to make the class thread safe such that clients don't need to do anything particular to use it, it should have proper synchronization mechanisms and propose "higher level" method that can run atomic operation on a combination of operations if necessary.

Think of AtomicInteger , for example, which has an incrementAndGet() method that would provide a superior approach. Your run method would then become:

for( int i = 0; i < 5; i++ ) {
  int newValue = counter.incrementAndGet();
  System.out.println(Thread.currentThread().getName() + " counter: " + newValue );
}

Answer 3

Your increment() method uses i++ which is in fact substituted by 3 instructions. If that method is not declared as synchronized then several threads may execute it at the same time which will lead to race conditions and incorrect results.

If increment() and getValue() are declared as synchronized and synchronized block code is commented, the output manifests visibility and race problems.

There are no race conditions in this case. You see different results because now increment() and getValue() are not executed atomically (by atomically I mean two methods as one synch block) and while one thread called increment() and is about to call getValue() another thread also called increment() .

So you need to make increment() and getValue() synchronized if you are planning to call them outside of synchronized block in your run method (and because they are declared as public there is a possibility to make such calls).