在java中，同步方法调用其他同步方法不会死锁。因为`synchronized`关键字使用的是对象监视器锁（monitor lock），这是一种可重入锁（reentrant lock）。当线程已经持有了某个对象的锁时，它再次进入该对象的其他同步方法或代码块，jvm会识别出当前线程已持有锁并增加锁的计数器，而不是让线程阻塞等待。
为什么可重入能避免死锁
可重入机制的核心在于锁的归属权记录。每个对象头中都包含一个锁状态字段和一个计数器。当线程第一次获取锁时，计数器加1；当线程进入被调用的同步方法时，由于目标对象相同，JVM检查发现当前线程就是锁的持有者，于是直接放行并将计数器再加1。只有当线程退出最外层的同步作用域后，计数器减1，直到计数器归零，锁才真正释放给其他线程。这种设计确保了同一个线程可以安全地嵌套调用同一对象的同步逻辑，而不会产生自我阻塞。
public class ReentrantExample {
public synchronized void outer() {
System.out.println("Outer method acquired lock");
inner(); // 调用内部同步方法
System.out.println("Outer method finished");
}
public synchronized void inner() {
System.out.println("Inner method executed");
}
public static void main(String[] args) {
ReentrantExample example = new ReentrantExample();
example.outer();
}
}
上述代码展示了标准的可重入行为。运行结果将依次打印“Outer method acquired lock”、“Inner method executed”和“Outer method finished”，整个过程没有发生任何阻塞或异常，证明了嵌套调用是安全的。
立即学习“Java免费学习笔记（深入）”；
什么情况下才会发生死锁
死锁通常发生在两个或多个线程互相持有对方需要的锁，且都不愿释放的情况下。例如，线程A持有对象X的锁并等待对象Y的锁，同时线程B持有对象Y的锁并等待对象X的锁。这种情况与是否在同一对象内调用无关，而是涉及多个不同资源的竞争。如果在同步方法中调用的是另一个不同对象的同步方法，且这两个调用发生在不同的线程上下文中形成了循环依赖，才可能引发死锁。但在单一线程内，无论嵌套多深，只要涉及的是同一个对象，就不会死锁。
public class DeadlockRisk {
private final Object lockA = new Object();
private final Object lockB = new Object();
public void methodA() {
synchronized (lockA) {
System.out.println("Holding A, waiting for B...");
try { Thread.sleep(10); } catch (InterruptedException e) {}
synchronized (lockB) { // 尝试获取B
System.out.println("Holding A and B");
}
}
}
public void methodB() {
synchronized (lockB) {
System.out.println("Holding B, waiting for A...");
try { Thread.sleep(10); } catch (InterruptedException e) {}
synchronized (lockA) { // 尝试获取A
System.out.println("Holding B and A");
}
}
}
}
如果在一个线程中调用`methodA`，而在另一个线程中调用`methodB`，并且执行顺序交错，就可能形成死锁。这与`synchronized`的可重入特性无关，而是多线程资源竞争的经典问题。开发者应避免交叉锁定多个不同对象，以预防此类情况。
嵌套调用时的锁计数变化
为了更清晰地理解锁的状态变化，我们可以观察锁计数器的具体数值。当线程进入外层同步方法时，计数器从0变为1；进入内层同步方法时，计数器从1变为2；退出内层方法时，计数器从2变回1；最后退出外层方法时，计数器从1变为0，此时锁完全释放。这种计数机制保证了锁的粒度控制，使得线程可以在复杂的业务逻辑中自由组合同步块，而不必担心因重复获取同一把锁而导致系统挂起。
