Java中的單例模式、多線程安全問題以及死鎖

單例模式，Java眾多設計模式中的一種，分為餓漢式和懶漢式（廷遲加載），簡要代碼如下：

饿漢式：

//餓漢式
public class Singleton {
    private static final Singleton singleton = new Singleton();
    private Singleton() {}
    public static Singleton getInstance() {
        return singleton;
    }
}

懶漢式（廷遲加載），因多線程訪問時存在線程安全問題，故應加同步鎖。如下：

//懶漢式 方式1
public class Singleton {
    private static Singleston singleton = null;
    private Singleton() {}
    //把鎖加在方法聲明上，變成同步函數
    public static synchronized Singleton getInstance() {
        if (singleton == null) {
            singleton = new Singleton();
        }
        return singleton;
    }
}
//方式1每次執行到getInstance()方法時都要檢查同步鎖，對程序運行性能的影響較大。

 

//懶漢式 方式2
public class Singleton {
    private static Singleston singleton = null;
    private Singleton() {}
    public static Singleton getInstance() {
        if (singleton == null) {
            //把鎖加在可能產生線程安全問題的代碼上，變成同步代碼塊
            synchronized(Singleton.class) {
                if (singleton == null) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}
//當同步代碼塊所在方法getInstance()非靜態時，synchronized(Singleton.class){}應改為synchronized(this){}。   
//即靜態時用該類的字節碼文件為參數，非靜態時用該類的實例對象為參數。

 

在實際開發中一般推薦使用餓漢式，因其代碼相對簡潔，且不存在多線程訪問的線程安全問題。

 

-------------------------------------------------------------------------------------------------------------------------

多線程訪問同一份共享資源時，可能產生線程安全問題，於是給共享資源加鎖，但這同時又會帶來另一個問題，就是死鎖。
何謂死鎖？死鎖是指兩個或兩個以上的線程在執行過程中因爭奪資源而造成互不相讓、互相等待的現象。
死鎖產生的條件有四個：
1.互斥條件：線程在某一時間內獨佔資源。
2.請求與保持條件：一個線程因請求資源而阻塞時，對已獲資源不放。
3.不剝奪條件：線程已獲得資源，在末使用完之前，不能強行剝奪。
4.循環等待條件：若干線程之間形成一種頭尾相接的循環等待資源關係。
形象點說，就是線程1鎖定了A資源又想去鎖定B資源，同時線程2鎖定了B資源又想去鎖定A資源，兩線程互不相讓，相持不下的現象。
簡單來說，就是同步中嵌套同步，而鎖卻不同。
多線程死鎖的簡要代碼如下：

//模擬多線程死鎖現象
public class ThreadDeadLock implements Runnable {
    private boolean flag;
    ThreadDeadLock(boolean flag) {
        this.flag = flag;
    }
    
    private static Object lock1 = new Object(); //定義兩個鎖，注意加static
    private static Object lock2 = new Object();
    
    public void run() {
        if (flag) {
            synchronized(lock1) {
                System.out.println(Thread.currentThread().getName() + " -- true -- A"); //t1線程獲得資源A
                synchronized(lock2) {
                    System.out.println(Thread.currentThread().getName() + " -- true -- B"); //t1線程獲得資源B
                }
            }
        } else {
            synchronized(lock2) {
                System.out.println(Thread.currentThread().getName() + " -- false -- B"); //t2線程獲得資源B
                synchronized(lock1) {
                    System.out.println(Thread.currentThread().getName() + " -- false -- A"); //t2線程獲得資源A
                }
            }
        }
    }
    
    public static void main(String[] args) {
        Thread t1 = new Thread(new ThreadDeadLock(true)); //新建兩個線程
        Thread t2 = new Thread(new ThreadDeadLock(false));
        t1.start(); //啟動線程
        t2.start();
    }
}

運行結果如下（參考）：

 

在使用synchronized解決Java多線程同步問題時應避免出現死鎖現象，只要破壞死鎖產生的四個條件中的一個即可。