Singleton单例

前言

以前我自认为对设计模式较为熟悉了，最起码最简单的单例模式应该已经很会了。可是，我真的会了吗？书只会越读越薄，每一次的回顾都带来新的发现。

第一种写法

这是最简单的一种写法，简单实用，推荐使用！

public class Mgr01 {
    private static final Mgr01 INSTANCE = new Mgr01();
    private Mgr01(){};
    public static Mgr01 getInstance(){
        return INSTANCE;
    }
    public void m(){
        System.out.println("m");
    }

    public static void main(String[] args) {
        Mgr01 m1 = Mgr01.getInstance();
        Mgr01 m2 = Mgr01.getInstance();
        System.out.println(m1 == m2);
    }
}

唯一缺点：不管用到与否，类加载时就完成实例化

第二种写法

这个其实跟第一种写法意思一样的，只不过是把初始化放在静态语句块里了。

public class Mgr02 {
    private static final Mgr02 INSTANCE;
    static {
        INSTANCE = new Mgr02();
    }
    private Mgr02(){};
    public static Mgr02 getInstance(){
        return INSTANCE;
    }
    public void m(){
        System.out.println("m");
    }

    public static void main(String[] args) {
        Mgr02 m1 = Mgr02.getInstance();
        Mgr02 m2 = Mgr02.getInstance();
        System.out.println(m1 == m2);
    }
}

第三种写法

该写法为懒汉式，虽然达到了按需初始化的目的，但却带来了线程不安全的问题。

public class Mgr03 {
    private static Mgr03 INSTANCE;
    private Mgr03(){};
    public static Mgr03 getInstance(){
        if (INSTANCE == null){
            INSTANCE = new Mgr03();
        }
        return INSTANCE;
    }
    public void m(){
        System.out.println("m");
    }

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            new Thread(()->{
                System.out.println(
                        Mgr03.getInstance().hashCode()
                );
            }).start();
        }
    }
}

第四种写法

上面第三种写法可以通过synchronized解决，但也带来效率低下。

public class Mgr04 {
    private static Mgr04 INSTANCE;
    private Mgr04(){};
    public static synchronized Mgr04 getInstance(){
        if (INSTANCE == null){
            INSTANCE = new Mgr04();
        }
        return INSTANCE;
    }
    public void m(){
        System.out.println("m");
    }

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            new Thread(()->{
                System.out.println(Mgr04.getInstance().hashCode());
            }).start();
        }
    }
}

第五种写法

对于上面的第四种写法，妄图通过减少同步代码块的方式见提高效率，然后不可行。

public class Mgr05 {
    private static Mgr05 INSTANCE;
    private Mgr05(){};
    public static  Mgr05 getInstance(){
        if (INSTANCE == null){
            synchronized(Mgr05.class){
                INSTANCE = new Mgr05();
            }
        }
        return INSTANCE;
    }
    public void m(){
        System.out.println("m");
    }

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            new Thread(()->{
                System.out.println(Mgr05.getInstance().hashCode());
            }).start();
        }
    }
}

第六种写法

在以前，这种写法是完美的一种写法，采用双重if判断。

public class Mgr06 {
    private static Mgr06 INSTANCE;
    private Mgr06(){
    }
    public static Mgr06 getInstance(){
        if (INSTANCE == null){
            synchronized (Mgr06.class){
                if (INSTANCE == null){
                    INSTANCE = new Mgr06();
                }
            }
        }
        return INSTANCE;
    }
    public void m(){
        System.out.println("m");
    }

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            new Thread(()->{
                System.out.println(Mgr06.getInstance().hashCode());
            }).start();
        }
    }
}

第七种写法

其实上面的第六种写法还不够完美，有一点小瑕疵，第七种写法采用了静态内部类方式，由JVM保证单例。这是最完美的两种写法之一，为什么说是之一，因为第八种也是最完美的写法之一。

public class Mgr07 {
    private Mgr07(){};
    private static class Mgr07Holder{
        private final static Mgr07 INSTANCE = new Mgr07();
    }
    public static Mgr07 getInstance(){
        return Mgr07Holder.INSTANCE;
    }
    public void m(){
        System.out.println("m");
    }

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            new Thread(()->{
                System.out.println(Mgr06.getInstance().hashCode());
            }).start();
        }
    }
}

第八种写法

这种写法出自《Effective Java》一书，作者亲自写出了一种最简单也最明了的写法，采用了枚举单例，这是八种写法中唯一一种可以避免反序列化的写法。同时也解决了线程同步。

public enum  Mgr08 {
    INSTANCE;
    public void m(){}

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            new Thread(()->{
                System.out.println(Mgr08.INSTANCE.hashCode());
            }).start();
        }
    }
}