源代码：https://gitee.com/AgentXiao/SingletonPattern
一、核心作用
保证一个类只有一个实例，并且提供一个访问该实例的全局访问点。
二、优点
单例模式只生成一个实例，减少了系统性能开销
三、各种版本的单例模式
实现单例模式的基本规则：
（1）构造器私有化，不让外部创建对象
（2）提供外部调用的对象的方法
1、饿汉式
饿汉式的特点是“饿”，即类加载时便创建对象。
//饿汉式：类初始化时立即加载
private static SingletonDome01 singleton = new SingletonDome01();
//构造器私有化，外部用户不能够创建对象
private SingletonDome01(){
}
//提供访问方法，每次访问返回的都是同一个对象
public static SingletonDome01 getSingleton(){
return singleton;
}
特点：
线程安全的：虚拟机保证只会装载一次该类，肯定不会发生并发访问的问题。因。
问题：
可能造成资源浪费：如果只是加载本类，而不是要调用getInstance()，甚至永远没有调用，则会造成资源浪费！
2、懒汉式
懒汉式的特点是“懒”，即类加载的时候不创建对象，在第一次调用访问方法时创建，再次调用时直接调用。
//懒汉式：类初始化时不立即加载
private static SingletonDome02 singleton;
//构造器私有化，外部用户不能够创建对象
private SingletonDome02(){
}
//提供访问方法，第一次访问时创建，之后直接返回。但是需要设置同步
public static synchronized SingletonDome02 getSingleton(){
if(singleton == null){
singleton = new SingletonDome02();
}
return singleton;
}
问题：
每次调用getInstance()方法都要同步，并发效率较低。在不加synchronized时，假设A、B同时访问，A创建了对象，但是由于B也是null，也创建了一个对象，导致创建了多个对象，不符合单例的原则。
3、双重检测锁
因为饿汉式会让整个方法进行等待，效率低。因此将同步内容下方到if内部，提高了执行的效率。不必每次获取对象时都进行同步，只有第一次才同步，创建了以后就没必要了。
//懒汉式：类初始化时不立即加载
private static SingletonDome03 singleton;
//构造器私有化，外部用户不能够创建对象
private SingletonDome03(){
}
//提供访问方法，第一次访问时创建，之后直接返回
public static SingletonDome03 getSingleton(){
if (singleton == null) {
SingletonDome03 sc;//第一次访问时定义一个对象
synchronized (SingletonDome03.class) {
sc = singleton;
if (sc == null) {
synchronized (SingletonDome03.class) {
if(sc == null) {
sc = new SingletonDome03();
}
}
singleton = sc;
}
}
}
return singleton;
}
由于编译器优化原因和JVM底层内部模型原因，偶尔会出问题。不建议使用。
4、静态内部类实现
//静态内部类不会立即加载，只有真正调用时才会加载
private static class SingletonClass{
private static final SingletonDome04 singleton = new SingletonDome04();
}
//构造器私有化，外部用户不能够创建对象
private SingletonDome04(){
}
//提供访问方法，第一次访问时创建，之后直接返回。但是需要设置同步
public static synchronized SingletonDome04 getSingleton(){
return SingletonClass.singleton;
}
说明：
（1）加载外部类时不会直接创建对象；
（2）只有在调用访问方法时才会加载静态内部类去创建对象，同时加载一次类保证了线程安全。singleton是static final类型，保证了内存中只有这样一个实例存在，而且只能被赋值一次，从而保证了线程安全性。
（3）兼备了并发高效调用和延迟加载的优势！
5、问题（针对以上四种方式）
（1）反射破解
SingletonDome02 s1 = SingletonDome02.getSingleton();
SingletonDome02 s2 = SingletonDome02.getSingleton();
System.out.println(s1);
System.out.println(s2);
System.out.println();
Class<SingletonDome02> clazz = (Class<SingletonDome02>) Class.forName("pri.xiaowd.singleton.SingletonDome02");
Constructor<SingletonDome02> c = clazz.getDeclaredConstructor(null);
c.setAccessible(true);//忽略权限
SingletonDome02 s3 = c.newInstance();//构造对象
SingletonDome02 s4 = c.newInstance();//构造对象
System.out.println(s3);
System.out.println(s4);
由此可见，利用反射破解了单例模式。
通过在私有化的构造方法中抛异常的方法可以解决。如果对象已经创建了，则报错。
private SingletonDome02(){
if(singleton != null){
throw new RuntimeException();
}
}
（2）反序列化破解
前提条件是SingletonDome02类实现了Serializable接口。
//通过反序列化破解单例
FileOutputStream fos = new FileOutputStream("d:/a.txt");
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(s1);
oos.close();
fos.close();
ObjectInputStream ios = new ObjectInputStream(new FileInputStream("d:/a.txt"));
SingletonDome02 s3 = (SingletonDome02) ios.readObject();
System.out.println(s3);
解决办法：在SingletonDome02类中定义一个方法.反序列化时会自动调用。
//反序列化时如果定义了readResolve则直接返回此对象，不需要再创建
private Object readResolve(){
return singleton;
}
6、枚举实现
//这个枚举元素本身就是单例
SINGLETON;
//自己想要的操作
public static void getSingleton() {
}
优点：
– 实现简单。
– 枚举本身就是单例模式。由JVM从根本上提供保障！避免通过反射和反序列化的漏洞。
缺点：
– 无延迟加载。
System.out.println(SingletonDome05.SINGLETON == SingletonDome05.SINGLETON);
返回true。
7、比较
常见的五种单例模式实现方式
– 主要：
• 饿汉式（线程安全，调用效率高。 但是，不能延时加载。）
• 懒汉式（线程安全，调用效率不高。 但是，可以延时加载。）
– 其他：
• 双重检测锁式（由于JVM底层内部模型原因，偶尔会出问题。不建议使用）
• 静态内部类式（线程安全，调用效率高。 但是，可以延时加载)
• 枚举式（线程安全，调用效率高，不能延时加载。并且可以天然的防止反射和反序列化漏洞！)
如何选用?
1、单例对象占用资源 少，不需要延时加载：枚举式 好于 饿汉式
2、单例对象 占用 资源 大，需要延时加载：静态内部类式 好于 懒汉式
四、各种方式的效率（相对）
long start = System.currentTimeMillis();
int ThreadNum = 10;
final CountDownLatch countDownLatch = new CountDownLatch(ThreadNum);
for(int i=0;i<ThreadNum;i++){
new Thread(new Runnable(){
@Override
public void run() {
for(int i=0;i<1000000;i++){
//Object o = SingletonDome04.getSingleton();
Object o = SingletonDome05.SINGLETON;
}
countDownLatch.countDown();
}
}).start();
}
countDownLatch.await();//main线程阻塞，直到计数器变为0，才会继续往下执行
long end = System.currentTimeMillis();
System.out.println("耗时："+(end - start));
饿汉式SingletonDome01 ： 86
懒汉式SingletonDome02 ： 374
双重检测锁SingletonDome03 ： 143
静态内部类SingletonDome03 ： 474
枚举SingletonDome03 ： 24
