java多线程中实例上获取的锁

Question

我读到java中的锁是在实例（对象）的基础上获得的（在实例方法的情况下）
还可以在类的对象上获取锁（在静态方法的情况下）。

但我想知道特定对象一次可以获得多少个锁？

一个对象可以同时拥有多个锁吗？
如果是，请举例说明。

请帮助我理清我的概念。

Answer 1

每个同步块仅适用于一个对象。对象不会拥有锁。它是锁定对象以对其进行操作的执行线程。

锁总是在对象上获得。例如下面是可以获得锁的两个实例。第一个锁定类（对象）的实例。

Object obj = new Object();

synchronized(obj) {
    workOnIt(obj);
}

第二个看起来像是锁定了一个班级。但 Test.class 是我的 Test 类的 java.lang.Class 实例的特殊表示。

synchronized(Test.class) {
    // call some static method here
}

Answer 2

一个线程可以持有多个对象的多个锁。但你必须自己承担风险（以避免死锁或性能下降）

synchronized (obj1)
{
  synchronized (obj2)
  {
    // do sth. against obj1 and obj2 
  }
}

Answer 3

锁（以同步块或方法的形式）有一个主要作用：同时只有一个线程可以进入该对象的同步块/方法，即只有一个线程可以是该锁的所有者（或“监视器”，正如 JLS 中所称的那样）。

（另一个效果是，当一个同步块内（或之前）更改的所有变量位于同一监视器上的后续同步块中（或之后）时，保证在其他线程中可见。）

您正在使用多少个对象/变量在此块中，是您的自由决定，但通常您对以某种方式组合在一起的所有数据使用一把锁，并且不应独立修改/访问。

请注意，在对象上拥有锁本身并不能避免其他线程更改/使用该对象，它只是避免其他线程在该对象上同步。所以一定要同步所有相关的方法（并且不要有公共变量）。

Answer 4

考虑带有同步块的方法（改编自 JVMS ）

public void foo(Object f) {
  synchronized(f) {
    doSomething();
  }
}

让我们将其翻译为伪代码（Java 和字节代码的混合！！！）：

public void foo(Object f) {
  monitorenter(f);
  try {
    doSomething();
    monitorexit(f);
  } catch(Throwable e) {
    monitorexit(f);
    throw e;
  }
}

这就是它的样子，如果字节码指令 < code>monitorenter 和 monitorexit 是 java 方法。

每个对象都有一个监视器。如果一个线程进入监视器并且监视器未被获取（锁定、获取），那么它会获取（锁定、获取）监视器并调用 doSomething()（这是下一行）。

如果现在有第二个线程出现并尝试进入对象 f 上的监视器，那么它会在此位置等待，直到对象 f 上的监视器被释放。当第一个线程调用两个 monitorexit 指令（字节码！！）之一时，监视器被释放。

回到问题 - 一个线程可以输入多少个监视器？可能没有限制（堆栈大小限制除外）。如果doSomething是另一个同步方法并且使用对象g的监视器，那么线程一也将进入该监视器并获取g上的监视器（如果有的话）。

它不是获取锁的对象，而是进入对象监视器的线程，并且该进程正在“锁定”。

Answer 5

当您使用静态方法获取类上的锁时，您将像其他任何对象一样获取对象上的锁。

class A {
    synchronized void foo() { 
        // do something.
    }

    static synchronized void bar() { 
        // do something.
    }
}

基本上与 相同

class A {
    void foo() { 
        Object locked = this;
        synchronized(locked) {
            // do something.
        }
    }

    static void bar() { 
        Object locked = A.this;
        synchronized(locked) {
            // do something.
        }
    }
}

唯一可能因其拥有的锁数量而令人困惑的类是 Lock 的实例。这是一种不同风格的锁，但也是一个对象，因此也有一个标准锁。所以你可以

Lock lock = new ReentrantLock();
lock.lock();
lock.unlock();

但是，你可以令人困惑

Lock lock = new ReentrantLock();
synchronized(lock) { // don't do this.
   lock.wait(); // argh.
}