Java同步：如果将Java中的多个方法设为原子/同步，那么是否同时将锁定应用于所有这些方法？

Question

Suppose there are 2 synchronized methods in my java code:

    public class SynchronizedCounter {
    private int c = 0;

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

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

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

Suppose i have 2 operating threads: t1 and t2. If t1 is operating on increment() method and goes to sleep midway, t2 won't be able to operate on increment() method because of locking. My question is will t2 be able to operate on decrement() and value(), or all the synchronized methods associated with an object gets locked as soon as a thread accesses one of the synchronized methods?

What about static synchronized methods?

Answer 1

A synchronized instance method uses the object instance as the lock. No two threads can enter these methods with the same object at the same time. if your t1 and t2 are operating on the same object, t2 will be blocked until t1 releases the lock.

For static synchronized methods the lock is put on the Class object for the class the methods are contained in.

You can read more about locking in the concurrency tutorial , but essentially the difference between static and non-static methods is the object which is locked; the method declarations in this class:

class Test {
  synchronized void methodA() { ... }
  static synchronized void methodB() { ... }
}

are equivalent to the method declarations here:

class Test {
  void methodA() { 
    synchronized (this) {
        ...
    }
  }
  static void methodB() { 
    synchronized (Test.class) {
        ...
    }
  }
}

Answer 2

文档动作指出：“当一个线程正在执行对象的同步方法时，所有其他线程调用同一对象的同步方法（挂起执行），直到第一个线程完成该对象为止。”你的问题。

Answer 3

当您将一个方法声明为已同步时，该实例对象将被视为锁。

Answer 4

Synchronized methods operate on the lock of the instance of the class they're in. So in short: if t1 sleeps in increment() no thread can access any synchronized method.

also your code snipped is identically to the example in the Java tutorials , which also provides your answer...

Answer 5

All synchronized instance methods of an object share the same lock, embodied by the object. All static synchronized methods share the same lock, embodied by the class object.

If you need more fine-grained locking, you need to use a synchronized block and separate lock objects, ie

private Object decrementLock = new Object();
public void decrement() {
    synchronized(decrementLock){
        c--;
    }
}

Of course, in this case this would defeat the point of synchronization and lead to corrupt data.

Answer 6

Locks are associated with the objects not with threads. More than 1 threads can access the synchronized method but the objects invokes the methods should be different.