带有synchronized关键字的Java锁

我在一个教程中看到了这一点，他们问下面的代码是否有问题。在我看来，b（）似乎无法访问，因为a（）已经控制了监视器。我这样想对吗

public class Test {
    public synchronized void a() {
        b();
        System.out.println("I am at a");
    }
    public synchronized void b() {
        System.out.println("I am at b");
    }
}

---

不，你错了。线程控制监视器，而不是方法，因此它能够根据需要跟踪执行到同一对象上同步的任意多个方法中

不，你错了。线程控制监视器，而不是方法，因此它能够根据需要跟踪执行到同一对象上同步的任意多个方法中

不，你错了。线程控制监视器，而不是方法，因此它能够根据需要跟踪执行到同一对象上同步的任意多个方法中

不，你错了。线程控制监视器，而不是方法，因此它能够根据需要跟踪执行到同一对象上同步的任意多个方法中

不，该代码没有问题。 注意两件事：

synchronized SomeType foo（）{…}

相当于

SomeType foo() {
    synchronized (this) { ... } 
}

它锁定封闭类的

这个

实例。因此，在您的例子中，

a（）

和

b（）

锁定了相同的东西

如果一个线程已经在某个对象的监视器上持有锁，它会阻止另一个线程在同一个对象上获取锁，但是同一个线程也可以在需要时获取更多锁，这不会受到影响。所以

public synchronized void a() {  // acquires lock on this
   b();                         // also aquires lock on this, but it's ok because it is the same thread
   System.out.println("I am at a");
}      

当一个线程位于

a（）

内时，其他线程将无法在同一实例上调用

a（）

或

b（）

。如果他们尝试这样做，则必须等待当前线程退出

a（）

。但是当前线程本身不受影响，它可以调用此对象上的任何同步方法，因为它已经持有锁

---

不，这个代码没有问题。 注意两件事：

synchronized SomeType foo（）{…}

相当于

SomeType foo() {
    synchronized (this) { ... } 
}

它锁定封闭类的

这个

实例。因此，在您的例子中，

a（）

和

b（）

锁定了相同的东西

如果一个线程已经在某个对象的监视器上持有锁，它会阻止另一个线程在同一个对象上获取锁，但是同一个线程也可以在需要时获取更多锁，这不会受到影响。所以

public synchronized void a() {  // acquires lock on this
   b();                         // also aquires lock on this, but it's ok because it is the same thread
   System.out.println("I am at a");
}      

当一个线程位于

a（）

内时，其他线程将无法在同一实例上调用

a（）

或

b（）

。如果他们尝试这样做，则必须等待当前线程退出

a（）

。但是当前线程本身不受影响，它可以调用此对象上的任何同步方法，因为它已经持有锁

---

不，这个代码没有问题。 注意两件事：

synchronized SomeType foo（）{…}

相当于

SomeType foo() {
    synchronized (this) { ... } 
}

它锁定封闭类的

这个

实例。因此，在您的例子中，

a（）

和

b（）

锁定了相同的东西

如果一个线程已经在某个对象的监视器上持有锁，它会阻止另一个线程在同一个对象上获取锁，但是同一个线程也可以在需要时获取更多锁，这不会受到影响。所以

public synchronized void a() {  // acquires lock on this
   b();                         // also aquires lock on this, but it's ok because it is the same thread
   System.out.println("I am at a");
}      

当一个线程位于

a（）

内时，其他线程将无法在同一实例上调用

a（）

或

b（）

。如果他们尝试这样做，则必须等待当前线程退出

a（）

。但是当前线程本身不受影响，它可以调用此对象上的任何同步方法，因为它已经持有锁

---

不，这个代码没有问题。 注意两件事：

synchronized SomeType foo（）{…}

相当于

SomeType foo() {
    synchronized (this) { ... } 
}

它锁定封闭类的

这个

实例。因此，在您的例子中，

a（）

和

b（）

锁定了相同的东西

如果一个线程已经在某个对象的监视器上持有锁，它会阻止另一个线程在同一个对象上获取锁，但是同一个线程也可以在需要时获取更多锁，这不会受到影响。所以

public synchronized void a() {  // acquires lock on this
   b();                         // also aquires lock on this, but it's ok because it is the same thread
   System.out.println("I am at a");
}      

当一个线程位于

a（）

内时，其他线程将无法在同一实例上调用

a（）

或

b（）

。如果他们尝试这样做，则必须等待当前线程退出

a（）

。但是当前线程本身不受影响，它可以调用此对象上的任何同步方法，因为它已经持有锁

---

有人在没有任何解释的情况下否决了这个？我也不知道答案，想解释一下吗？我不知道投票被否决的原因，但似乎OP并没有试过。有人在没有任何解释的情况下否决了这个？我也不知道答案，想解释一下吗？我不知道投票被否决的原因，但似乎OP并没有试过。有人在没有任何解释的情况下否决了这个？我也不知道答案，想解释一下吗？我不知道投票被否决的原因，但似乎OP并没有试过。有人在没有任何解释的情况下否决了这个？我也不知道答案，想解释一下吗？我不知道投反对票的原因，但似乎OP并没有试过。