Java多線程產生死鎖的一個簡單案例

synchronized是Java中的關鍵字，是一種同步鎖。它修飾的對象有以下幾種：

1. 修飾一個代碼塊，被修飾的代碼塊稱為同步語句塊，其作用的范圍是大括號{}括起來的代碼，作用的對象是調用這個代碼塊的對象；
2. 修飾一個方法，被修飾的方法稱為同步方法，其作用的范圍是整個方法，作用的對象是調用這個方法的對象；
3. 修改一個靜態方法，其作用的范圍是整個靜態方法，作用的對象是這個類的所有對象；
4. 修改一個類，其作用的范圍是synchronized后面括號括起來的部分，作用主的對象是這個類的所有對象。

首先，我們在java中創建兩個字符串，strA 、strB。讓每個線程都用synchronized鎖住字符串（線程A先鎖strA ，再去鎖strB；線程B先鎖strA，再鎖strB），如果線程A鎖住strA ，線程B鎖住strB，線程A就沒辦法鎖住strB，線程B也沒辦法鎖住strA，這個時候就陷入了死鎖。

 

package com.abcd;

public class Test {
    public static String objA = "strA";
    public static String objB = "strB";
    public static void main(String[] args){
        Thread a = new Thread(new Lock1());
        Thread b = new Thread(new Lock2());
        a.start();
        b.start();
    }    
}
class Lock1 implements Runnable{
    @Override
    public void run(){
        try{
            System.out.println("Lock1 running");
            while(true){
                synchronized(Test.objA){
                    System.out.println("Lock1 lock strA");
                    Thread.sleep(3000);//獲取strA后先等一會兒，讓Lock2有足夠的時間鎖住strB
                    synchronized(Test.objB){
                        System.out.println("Lock1 lock strB");
                    }
                }
            }
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}
class Lock2 implements Runnable{
    @Override
    public void run(){
        try{
            System.out.println("Lock2 running");
            while(true){
                synchronized(Test.objB){
                    System.out.println("Lock2 lock strB");
                    Thread.sleep(3000);
                    synchronized(Test.objA){
                        System.out.println("Lock2 lock strA");
                    }
                }
            }
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}