Java多執行緒案例之單例模式懶漢+餓漢+列舉

//單例模式 - 餓漢模式
class HungrySingleton {
    //1.使用一個變數來儲存該類唯一的範例，因為單例模式在一個程式中只能擁有一個範例，由於static成員只有一份，我們可以使用static變數來儲存
    private static final HungrySingleton instance = new HungrySingleton();

    //2.封裝構造方法，防止該類被範例出新的物件
    private HungrySingleton() {}

    //3.獲取該類的唯一範例物件
    public HungrySingleton getInstance() {
        return instance;
    }
}

//單例模式 - 懶漢模式
class SlackerSingleton {
    //1.使用一個變數來儲存該類唯一的範例，因為單例模式在一個程式中只能擁有一個範例，由於static成員只有一份，我們可以使用static變數來儲存
    //懶漢單例模式是在使用的時候建立物件，因此初始時物件不應該被建立
    private static SlackerSingleton instance;

    //2.封裝構造方法，防止該類被範例出新的物件
    private SlackerSingleton() {}

    //3.獲取該類的唯一物件，如果沒有就建立
    public SlackerSingleton getInstance() {
        if (instance == null) {
            instance = new SlackerSingleton();
        }
        return instance;
    }
}

//多執行緒情況下餓漢模式獲取物件時唯讀不修改，所以是執行緒安全的
//多執行緒情況下懶漢模式獲取物件時存在兩次讀操作，分別為判斷instance是否為null和返回instance，除了讀操作還存在修改操作，即新建物件並使instance指向該物件
//懶漢模式物件還未初始化的時候，可能會存在多個執行緒進入判斷語句，會導致範例出多個物件，因此懶漢單例模式是執行緒不安全的。

//執行緒安全單例模式 - 懶漢模式
class SafeSlackerSingleton {
    //1.使用一個變數來儲存該類唯一的範例，因為單例模式在一個程式中只能擁有一個範例，由於static成員只有一份，我們可以使用static變數來儲存
    //懶漢單例模式是在使用的時候建立物件，因此初始時物件不應該被建立
    private static SafeSlackerSingleton instance;

    //2.封裝構造方法，防止該類被範例出新的物件
    private SafeSlackerSingleton() {}

    //3.獲取該類的唯一物件，如果沒有就建立
    public SafeSlackerSingleton getInstance() {
        synchronized (SafeSlackerSingleton.class) {
            if (instance == null) {
                instance = new SafeSlackerSingleton();
            }
        }
        return instance;
    }
}

    public SafeSlackerSingletonPlus getInstance() {
        //判斷instance是否初始化，如果已經初始化了，那麼該方法只有兩個讀操作，本身就是執行緒安全的，不需要加鎖了，這樣能減少鎖競爭，提高效率
        if (instance == null) {
            synchronized (SafeSlackerSingletonPlus.class) {
                if (instance == null) {
                    instance = new SafeSlackerSingletonPlus();
                }
            }
        }
        return instance;
    }

//執行緒安全優化單例模式 - 懶漢模式
class SafeSlackerSingletonPlus {
    //1.使用一個變數來儲存該類唯一的範例，因為單例模式在一個程式中只能擁有一個範例，由於static成員只有一份，我們可以使用static變數來儲存
    //懶漢單例模式是在使用的時候建立物件，因此初始時物件不應該被建立
    private static volatile SafeSlackerSingletonPlus instance;

    //2.封裝構造方法，防止該類被範例出新的物件
    private SafeSlackerSingletonPlus() {}

    //3.獲取該類的唯一物件，如果沒有就建立
    public SafeSlackerSingletonPlus getInstance() {
        //判斷instance是否初始化，如果已經初始化了，那麼該方法只有兩個讀操作，本身就是執行緒安全的，不需要加鎖了，這樣能減少鎖競爭，提高效率
        //如果執行緒很多，頻繁進行外層或內層if判斷，可能會引發內層可見性問題，因此要給instan變數加上volatile
        if (instance == null) {
            synchronized (SafeSlackerSingletonPlus.class) {
                if (instance == null) {
                    instance = new SafeSlackerSingletonPlus();
                }
            }
        }
        return instance;
    }
}

//單元素的列舉型別已經成為實現Singleton的最佳方法
enum  EnumSingleton {
    INSTANCE;
    public void doSomething() {
        System.out.println("完成一些任務！");
    }
}

public class Singleton {
    public static void main(String[] args) {
        EnumSingleton.INSTANCE.doSomething();
    }
}