java - Java 如何处理以下场景？

Question

我尝试了一些代码来证明同步块(synchronized block)锁定机制的可靠性。考虑我的示例代码

我的时钟对象。

public class MyLock {
final static Object lock=new Object();
}

带有同步块(synchronized block)的类

public class Sample {

public void a(String input) {
    System.out.println(input+" method a");
    synchronized (lock) {
        System.out.println("inside synchronized block in a");
        try {
            System.out.println("waiting in a");
            Thread.sleep(5000);
            System.out.println("calling b() from a");
            new Sample().b("call from a");
            System.out.println("waiting again in a");
            Thread.sleep(5000);
            System.out.println("Running again a");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public void b(String input) {
    System.out.println(input+" method b");
    synchronized (lock) {
        System.out.println("bbb " + input);
    }
 }

}

测试1类

public class Test1 implements Runnable{

public static void main(String[] args) {
   new Thread(new Test1()).start();
   new Thread(new Test2()).start();
}

@Override
public void run() {
   new Sample().a("call from main");
 }
}

测试2类

public class Test2 implements Runnable {
@Override
public void run() {
   new Sample().b("call from main");
 }
}

我这样做是因为我认为如果持有锁的同一线程要访问使用同一锁锁定的另一个方法，将会出现死锁情况。现在考虑输出

call from main method a
call from main method b
inside synchronized block in a
waiting in a
calling b() from a // i thought this will cause a dead lock
call from a method b
bbb call from a
waiting again in a
Running again a
bbb call from main 

现在你可以看到没有这个问题了。我的问题是 Java 如何处理这种情况？

Answer 1

同步 block 是可重入的

默认情况下，synchronized block 中使用的锁(准确地说是互斥体)是 Reentrant ，这意味着如果同一个线程尝试再次获取相同的锁，它将不必等待，并且会立即进入关键 block ，因为它已经拥有该锁。

重入在哪里有用？

简单的答案是递归。

考虑同步方法上的递归场景，

int synchronized method(int param){
   //... some logic

   method(param - 1);
}

在此示例中，您不希望同一线程因同一锁而被阻塞，因为它将永远无法继续。

在这种情况下会发生死锁:

Thread A acquires lock A
Thread B acquires lock B
Thread A tries to acquire lock B
Thread B tries to acquire lock A

现在在这种情况下，没有人能够继续进行，因此陷入僵局。但在您的场景中只有一个锁，因此另一个线程将等待第一个线程离开锁然后继续。