Java Synchronized会同步一个类的所有同步方法吗？

Question

I've a question about synchronization in java. In the following Java program I dont get any output. But, if I remove the synchronized statement from the method IFoo.s() I'll get some output. It seems like the methods IFoo.setP() and IFoo.s() are synchronized among each other. But 'synchronized' should only prevent that two threads call the synchronized method at the same time, right?

package com.example.relectiontest;

import java.awt.Point;
import java.util.Random;

public class Main {

public static void main(String[] args) throws Exception{
    final IFoo f = new IFoo();
    Runnable r = new Runnable() {
        public void run() {
            Random r = new Random();
            int a = r.nextInt(5)+1;
            for(int i=0;i<1000000;++i){
                f.setP(a);
            }
        }
    };
    Runnable r2 = new Runnable() {
        public void run() {
            for(int i=0;i<1000000;++i){
                f.s();
            }
        }
    };
    Thread T1 = new Thread(r, "T1");
    Thread T2 = new Thread(r, "T2");
    Thread T3 = new Thread(r2, "T3");
    T3.start();
    T1.start();
    T2.start();
}

private static class IFoo{
    private Point p = new Point();

    public synchronized void setP(int a){
        //System.out.println("p1 "+Thread.currentThread());
        p.x = a;
        p.y = p.x;
        int x = p.x , y = p.y;
        if(x != y)
            System.out.println(Thread.currentThread()+"\t"+x+" "+y);
        //System.out.println("p2 "+Thread.currentThread());
    }

    public synchronized void s(){
        //System.out.println("s");
        p.x = 0;
    }
}
}

So, why I cant see any output?

regards

Answer 1

Because thanks to synchronization x != y will never be true.

In your unsynchronized version s() has the chance of setting px to 0 every once in a while (even though it's not synchronized properly).

In the synchronized version s() must wait until setP is finished (since they're both synchronized, sharing the implicit this lock), and thanks to the logic in setP the condition can not be true.

Your example is overly complex. You can write it out as follows (adding synchronized on both methods to see that nothing will be printed):

private static class IFoo {
    volatile int x = 0;
    public void setP(int a) {
        x = a;
        if(x != a)
            System.out.println("Someone changed x!");
    }

    public void s() {
        x = 0;
    }
}

Also note that static synchronized methods synchronize on the Class object since they have no this . Instance and static methods therefore won't lock each other unless you explicitly synchronize on a common lock.

Answer 2

In Java all synchronized calls are synchronized on an object. For instance methods, they object is the class instance - so in your case setP and s are both synchronized on the instance of IFoo .

This allows you to control access to shared fields which are accessed through more than one method. With your code, this will be exactly what you need - you need to make sure you don't have one thread in setP changing the state while another in s is reading it.

If you prefer finer control you can use synchronized blocks, which allow you to specify the object to lock on:

private final Object o=new Object();

public void method(){
    synchronized (o){
        //Synchronized code
    }
}

This is the generally generally recommended approach - it allows you to encapsulate your lock, so you don't risk some other class interfering with your locks and potentially DOSing your code.

Static methods are synchronized on the class object (such as IFoo.class ).

Answer 3

From documentation :

making these methods synchronized has two effects:

First, it is not possible for two invocations of synchronized methods on the same object to interleave. When one thread is executing a synchronized method for an object, all other threads that invoke synchronized methods for the same object block (suspend execution) until the first thread is done with the object.

Second, when a synchronized method exits, it automatically establishes a happens-before relationship with any subsequent invocation of a synchronized method for the same object. This guarantees that changes to the state of the object are visible to all threads.

Answer 4

The output will be displayed only when:

 if(x != y) 

Because in lines:

 p.x = a;
 p.y = p.x;
 int x = p.x , y = p.y;

You make x == y that output is not displayed.

When you remove synchronization keyword from s method - the threads sometimes set x to 0 and this make if(x != y) - to true. and output is visible.

Answer 5

Because normally you shouldn't get any output as x should be equal to y. However, when you remove the synchronized keyword, two threads execute at the same time and you may get an output if s() executes between py=px and x=px statements.