单例模式

什么是单例？

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

应用场景

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

代码实现

饿汉式

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

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

1 public class Goddess {
2     
3 }

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

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

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

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

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

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

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

　　我们来验证一下：

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

　　结果：

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

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

懒汉式

 1 public class Goddess {
 2     private static Goddess goddess ;//此时不创建对象
 3     private Goddess(){};//私有化构造
 4     public static Goddess getInstance(){//获取唯一可用的对象
 5 
 6         if (goddess == null) {//如果没有女娲才去创建
 7             goddess = new Goddess();
 8         }
 9         return goddess;
10     }
11 }

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

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

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

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

 1 public class Goddess {
 2     private static Goddess goddess ;//此时不创建对象
 3     private Goddess(){};//私有化构造
 4     public static synchronized Goddess getInstance(){//获取唯一可用的对象
 5 
 6         if (goddess == null) {//如果没有女娲才去创建
 7             goddess = new Goddess();
 8         }
 9         return goddess;
10     }
11 }

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

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

　　代码如下：

双检锁/双重校验锁

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

枚举模式

1 public enum Goddess {
2     INSTANCE;
3     public Goddess getInstance(){
4         return INSTANCE;
5     }
6 }

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

我们以饿汉式为例：

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

　　结果：

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

　　枚举单例下示例：

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

　　结果：

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