爲什麼它不會造成死鎖？

Question

請參考下面的代碼

package com.test; 

public class DeadLock { 

    private void method1() { 

     synchronized (Integer.class) { 
      method2(); 
     } 
    } 

    private void method2() { 
     synchronized (Integer.class) { 
      System.out.println("hi there"); 
     } 
    } 

    public static void main(String[] args) { 
     new DeadLock().method1(); 
    } 
} 

按我的理解，在method2代碼不應該在任何情況下執行，因爲method1持有Integer.class和method2嘗試鎖再次訪問Integer.class鎖。但令我驚訝的是，代碼運行良好，它向控制檯輸出「hi there」。有人可以澄清嗎？

Answer 1

鎖由線程所有。如果你的線程已經擁有一個鎖，那麼Java假定你不需要再次獲取它並繼續。

，如果你在method1()開始秒線程在佔用鎖和第二個線程執行方法method2()你會得到一個僵局。

如果你喜歡的代碼，然後​​是這樣的：

Lock lock = Integer.class.getLock(); 
boolean acquired = false; 
try { 
    if(lock.owner != Thread.currentThread()) { 
     lock.acquire(); 
     acquired = true; 
    } 

    ...code inside of synchronized block... 
} finally { 
    if(acquired) lock.release(); 
} 

這裏是代碼演示了僵局。只需設置runInThread到true：

package com.test; 

public class DeadLock { 

    private void method1() { 

     synchronized (Integer.class) { 
      boolean runInThread = false; 

      if(runInThread) { 
       Thread t = new Thread() { 
        @Override 
        public void run() { 
         method2(); 
        } 
       }; 
       t.start(); 
       try { 
        t.join(); // this never returns 
       } catch(InterruptedException e) { 
        e.printStackTrace(); 
       } 
      } else { 
       method2(); 
      } 
     } 
    } 

    private void method2() { 
     System.out.println("trying to lock"); 
     synchronized (Integer.class) { 
      System.out.println("hi there"); 
     } 
    } 

    public static void main(String[] args) { 
     new DeadLock().method1(); 
    } 
} 

Answer 2

你的代碼就相當於：

synchronized (Integer.class) { 
    synchronized (Integer.class) { 
     System.out.println("hi there"); 
    } 
} 

如果線程獲取鎖，進入第一​​塊它不會有任何問題訪問第二

爲了產生死鎖，對method2的調用應該由不同的線程執行。

Answer 3

看來你誤解了這個概念。 方法永遠不會獲取鎖，在同步方法的情況下，調用該方法的實例用作鎖，並且在同步塊的情況下線程獲取指定對象上的鎖。

這裏實例獲取Integer.class上的鎖，然後繼續執行method2。

不存在死鎖情況，因爲在您的情況下線程繼續執行您在method1內調用的方法。所以沒有發生死鎖。

Answer 4

synchronized (Integer.class) { 
      method2(); 
     } 

當你調用這個 method2();那麼它不給鎖定任何種類的

mehtod其繼續去您調用手段這個方法。

private void method2() { 
     synchronized (Integer.class) { 
      System.out.println("hi there"); 
     } 
    } 

並完成其返回。所以沒有死鎖的情況。希望這個解釋有幫助。

Answer 5

如前所述，當沒有其他線程已經阻止它時，一個線程可以訪問多個同步塊。在這種情況下，同一個線程可以重新輸入同步塊，因爲它已經從method1中保持它。

爲了導致死鎖，您必須至少使用兩個線程和兩個不同的鎖。它必須以相反的順序訪問兩個鎖。看看代碼：

private void method1() throws InterruptedException 
{ 
    synchronized (Integer.class) 
    { 
     System.out.println(Thread.currentThread().getName() + " hi there method 1"); 
     Thread.sleep(1000); 
     method2(); 
    } 
} 

private void method2() throws InterruptedException 
{ 
    synchronized (Double.class) 
    { 
     System.out.println(Thread.currentThread().getName() + " hi there method 2"); 
     Thread.sleep(1000); 
     method1(); 
    } 
} 

public static void main(String[] args) throws InterruptedException 
{ 
    new Thread() 
    { 
     @Override 
     public void run() 
     { 
      try 
      { 
       new DeadLock().method1(); 
      } 
      catch (InterruptedException e) 
      { 
       e.printStackTrace(); 
      } 
     } 
    }.start(); 
    new DeadLock().method2(); 
}