设计模式之美—单例模式

单例模式

什么是单例？

1. 该类只能有一个实例。
2. 该类负责创建自己的对象。
3. 在整个项目中都能访问到这个实例。

应用场景

1. 读配置文件时，维护全局的Config类。
2. 线程池、连接池，统一进行分配和管理。
3. 网站的计数器，也可以采用单例模式实现，保持同步

代码实现

饿汉式

 　　中国古代神话中有女娲补天一说，现在天破了，我们去求女娲补天。

　　女娲用英语来说是 A Goddess In Chinese Mythology，意思就是神话中的女神，女娲是独一无二的，现在我们就建一个女神类Goddess。

public class Goddess {
    
}

　　神话中，我们都是女娲造出来的，人是不能造女娲的，所以要女娲私有化构造。

public class Goddess {
    private Goddess(){};//私有化构造
}

　　既然人不能女娲，那女娲是怎么来的，女娲伴随天地初开产生的，所以要自己创建对象。

public class Goddess {
    private static final Goddess goddess = new Goddess();//自己创建对象
    private Goddess(){};//私有化构造
}

　　女娲是神秘的，凡胎肉眼看不到所以要private，static保证了女娲伴随天地初开，在内存中永生，不能被垃圾回收器回收。final保证女娲是不会变的，永远是那个女神，啧...啧...

public class Goddess {
    private static final Goddess goddess = new Goddess();//自己创建对象
    private Goddess(){};//私有化构造
    public static Goddess getInstance(){//获取唯一可用的对象
        return goddess;
    }
}

　　既然单例不能被实例化，就需要一个静态的方法来获取对象。这是单例的“饿汉式”，代码第二行就产生了女娲。

　　我们来验证一下：

public class GoddessTest {
    public static void main(String[] args){
        Goddess goddes1 = Goddess.getInstance();
        Goddess goddes2 = Goddess.getInstance();
        System.out.println("两个对象的引用是否相等："+(goddes1==goddes2));
    }
}

　　结果：

两个对象的引用是否相等：true

　　两个对象的引用是同一个对象，说明我们实现了单例模式。

懒汉式

public class Goddess {
    private static Goddess goddess ;//此时不创建对象
    private Goddess(){};//私有化构造
    public static Goddess getInstance(){//获取唯一可用的对象

        if (goddess == null) {//如果没有女娲才去创建
            goddess = new Goddess();
        }
        return goddess;
    }
}

　　女娲比较懒，没事干的时候，处于混沌状态，第一次求女娲时，女娲才会实例化。

　　好处：省了一段时间的内存，

　　坏处：第一次请女娲会慢，因为要消耗CPU去实例化。多线程下也有问题，如果多个人同时请女娲，会产生很多女娲，不是线程安全。

　　我们加上synchronized进行优化，线程调用前必须获取同步锁，调用完后会释放锁给其他线程用，也就是请女娲必须排队，大家一个一个来。

public class Goddess {
    private static Goddess goddess ;//此时不创建对象
    private Goddess(){};//私有化构造
    public static synchronized Goddess getInstance(){//获取唯一可用的对象

        if (goddess == null) {//如果没有女娲才去创建
            goddess = new Goddess();
        }
        return goddess;
    }
}

　　然而，这样多个人都要去抢锁，即使对象已经实例化，没有充分利用CPU资源并发优势（特别是多核情况）。

　　我们把synchronized放到方法体内，如果女娲还没实例化，才回去抢锁，这就极大的利用了CPU资源。

　　代码如下：

双检锁/双重校验锁

//这种方式采用双锁机制，安全且在多线程情况下能保持高性能。
public class Goddess {
    private volatile static Goddess goddess ;//此时不创建对象
    private Goddess(){};//私有化构造
    public static Goddess getInstance(){//获取唯一可用的对象
        if (goddess == null) {//如果女娲还没有实例化，请女娲的人进行等待，准备抢夺请求锁。
            synchronized(Goddess.class){
                if (goddess == null) {//第一个抢过之后，后面的人也不用等待了，女娲还有五秒到达战场
                    goddess = new Goddess();
                }
            }
        }
        return goddess;
    }
}

 枚举模式

public enum Goddess {
    INSTANCE;
    public Goddess getInstance(){
        return INSTANCE;
    }
}

　　以上方式是在不考虑反射和序列化的情况下实现的，如果考虑了反射，就无法做到单例类只能有一个实例这种说法了。但是枚举单例模式可以避免这两种情况。

我们以饿汉式为例：

public class GoddessTest {
    public static void main(String[] args) throws Exception {
        Goddess goddes1=Goddess.getInstance();
        Goddess goddes2=Goddess.getInstance();
        Constructor<Goddess> constructor=Goddess.class.getDeclaredConstructor();
        constructor.setAccessible(true);
        Goddess goddes3=constructor.newInstance();
        System.out.println("正常情况下，两个对象的引用是否相等："+(goddes1 == goddes2));
        System.out.println("反射攻击时，两个对象的引用是否相等："+(goddes1 == goddes3));
    }
}

　　结果：

正常情况下，两个对象的引用是否相等：true
反射攻击时，两个对象的引用是否相等：false

　　枚举单例下示例：

public class GoddessTest {
    public static void main(String[] args) throws Exception {
        Goddess goddes1=Goddess.INSTANCE;
        Goddess goddes2=Goddess.INSTANCE;
        Constructor<Goddess> constructor= null;
        constructor = Goddess.class.getDeclaredConstructor();
        constructor.setAccessible(true);
        Goddess goddes3= null;
        goddes3 = constructor.newInstance();
        System.out.println("正常情况下，两个对象的引用是否相等："+(goddes1 == goddes2));
        System.out.println("反射攻击时，两个对象的引用是否相等："+(goddes1 == goddes3));
    }
}

　　结果：

Exception in thread "main" java.lang.NoSuchMethodException: xxx.xxx.Goddess.<init>()
    at java.lang.Class.getConstructor0(Class.java:3082)
    at java.lang.Class.getDeclaredConstructor(Class.java:2178)
    at com.slw.design.danli.GoddessTest.main(GoddessTest.java:11)

　　反射通过newInstance创建对象时，会检查该类是否enum修饰，如果是则抛出异常，反射失败。所以枚举是不怕发射攻击的。