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

    //2.封裝構(gòu)造方法，防止該類被實例出新的對象
    private HungrySingleton() {}

    //3.獲取該類的唯一實例對象
    public HungrySingleton getInstance() {
        return instance;
    }
}

//單例模式 - 懶漢模式
class SlackerSingleton {
    //1.使用一個變量來保存該類唯一的實例，因為單例模式在一個程序中只能擁有一個實例，由于static成員只有一份，我們可以使用static變量來保存
    //懶漢單例模式是在使用的時候創(chuàng)建對象，因此初始時對象不應(yīng)該被創(chuàng)建
    private static SlackerSingleton instance;

    //2.封裝構(gòu)造方法，防止該類被實例出新的對象
    private SlackerSingleton() {}

    //3.獲取該類的唯一對象，如果沒有就創(chuàng)建
    public SlackerSingleton getInstance() {
        if (instance == null) {
            instance = new SlackerSingleton();
        }
        return instance;
    }
}

//多線程情況下餓漢模式獲取對象時只讀不修改，所以是線程安全的
//多線程情況下懶漢模式獲取對象時存在兩次讀操作，分別為判斷instance是否為null和返回instance，除了讀操作還存在修改操作，即新建對象并使instance指向該對象
//懶漢模式對象還未初始化的時候，可能會存在多個線程進入判斷語句，會導(dǎo)致實例出多個對象，因此懶漢單例模式是線程不安全的。

//線程安全單例模式 - 懶漢模式
class SafeSlackerSingleton {
    //1.使用一個變量來保存該類唯一的實例，因為單例模式在一個程序中只能擁有一個實例，由于static成員只有一份，我們可以使用static變量來保存
    //懶漢單例模式是在使用的時候創(chuàng)建對象，因此初始時對象不應(yīng)該被創(chuàng)建
    private static SafeSlackerSingleton instance;

    //2.封裝構(gòu)造方法，防止該類被實例出新的對象
    private SafeSlackerSingleton() {}

    //3.獲取該類的唯一對象，如果沒有就創(chuàng)建
    public SafeSlackerSingleton getInstance() {
        synchronized (SafeSlackerSingleton.class) {
            if (instance == null) {
                instance = new SafeSlackerSingleton();
            }
        }
        return instance;
    }
}

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

//線程安全優(yōu)化單例模式 - 懶漢模式
class SafeSlackerSingletonPlus {
    //1.使用一個變量來保存該類唯一的實例，因為單例模式在一個程序中只能擁有一個實例，由于static成員只有一份，我們可以使用static變量來保存
    //懶漢單例模式是在使用的時候創(chuàng)建對象，因此初始時對象不應(yīng)該被創(chuàng)建
    private static volatile SafeSlackerSingletonPlus instance;

    //2.封裝構(gòu)造方法，防止該類被實例出新的對象
    private SafeSlackerSingletonPlus() {}

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

//單元素的枚舉類型已經(jīng)成為實現(xiàn)Singleton的最佳方法
enum  EnumSingleton {
    INSTANCE;
    public void doSomething() {
        System.out.println("完成一些任務(wù)！");
    }
}

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