目录：

一：单例模式的核心作用、常见应用场景

二：五种单例模式及其实现

三：关于反射和反序列化破解单例模式的漏洞，以及相应的解决方案

四：测试五种单例模式的效率

一：核心作用及常见应用场景：

核心作用：保证一个类只有一个实例对象，并且提供一个访问该实例对象的全局访问点（获取实例对象的方法），通过该访问点获得对象唯一

常见应用场景：

二：五种单例模式及其实现方式~~(附代码)

1. 饿汉式：

饿汉式单例模式代码中， static变量会在类装载时初始化，此时也不会涉及多个线程对象访问该对象的问题。虛拟机保证只会装载一次该类，肯定不会发生并发访问的问题。因此，可以省略synchronized关键字。

问题：如果只是加载本类，而不是要调用 getinstance()，甚至永远没有调用，则会造成资源浪费！

package 设计模式;/*** 测试饿汉式单例模式* 线程安全* 立即加载*/
public class Singleton1 {//类初始化时立即加载（没有延时加载的优势），加载类时，天然是线程安全的public static Singleton1 instance = new Singleton1();//构造器私有private Singleton1() {}//方法没有同步，调用效率高public static Singleton1 getInstance() {return instance;}public static void main(String[] args) {Singleton1 singleton1 = Singleton1.getInstance();Singleton1 singleton2 = singleton1.getInstance();System.out.println(singleton1 == singleton2);//true}
}

2.  懒汉式

要点: lazy load 延迟加载，只有真正用的时候才加载！

问题: 资源利用率高了。但是，每次调用 getinstanceO方法都要同步，并发效率较低。

package 设计模式;/*** 测试懒汉式单例模式* 线程安全* 延时加载*/
public class Singleton2 {//类初始化时，不初始化这个对象（延时加载，真正用的时候才加载）public static Singleton2 instance;//构造器私有private Singleton2() {}//方法同步，调用效率低public static Singleton2 getInstance() {if (instance == null)instance = new Singleton2();return instance;}public static void main(String[] args) {Singleton2 singleton1 = Singleton2.getInstance();Singleton2 singleton2 = singleton1.getInstance();System.out.println(singleton1 == singleton2);//true}
}

3. 双重检测锁式：（不建议使用！！）

看看代码就ok~

package 设计模式;/*** 测试双重检查锁单例模式* 不建议使用*/
public class Singleton3 {//类初始化时，不初始化这个对象（延时加载，真正用的时候才加载）public static Singleton3 instance = null;//构造器私有private Singleton3() {}//方法同步，调用效率低public static Singleton3 getInstance() {if (instance == null) {Singleton3 sc;synchronized (Singleton3.class) {sc = instance;if (sc == null) {synchronized (Singleton3.class) {if (sc == null)sc = new Singleton3();}instance = sc;}}}return instance;}public static void main(String[] args) {Singleton3 singleton1 = Singleton3.getInstance();Singleton3 singleton2 = singleton1.getInstance();System.out.println(singleton1 == singleton2);//true}
}

4. 静态内部类式：

要点：

1. 外部类没有 static属性，则不会像饿汉式那样立即加载对象
2. 只有真正调用 getinstance()，才会加载静态内部类。加载类时是线程安全的。 Instance是 static final类型，保证了内存中只有这样一个实例存在，而且只能被赋值一次，从而保证了线程安全性。
3. 兼备了并发高效调用和延迟加载的优势！

package 设计模式;/*** 测试静态内部类单例模式* 线程安全，调用效率高，并且实现延迟加载*/
public class Singleton4 {//静态内部类private static class SingletonClassInstance {private static final Singleton4 instance = new Singleton4();}//构造器私有private Singleton4() {}public static Singleton4 getInstance() {return SingletonClassInstance.instance;}public static void main(String[] args) {Singleton4 singleton1 = Singleton4.getInstance();Singleton4 singleton2 = singleton1.getInstance();System.out.println(singleton1 == singleton2);//true}
}

5. 枚举单例：

优点: 实现简单,枚举本身就是单例模式。由JVM从根本上提供保障！避免通过反射和反序列化的漏洞！

缺点:无延迟加载

package 设计模式;/*** 测试枚举单例模式* 实现简单,枚举本身就是单例模式。由JVM从根本上提供保障！避免通过反射和反序列化的漏洞！* 无延时加载*/
public enum Singleton5 {//这个枚举元素，本身就是单例模式INSTANCE;//添加自己需要的操作public void singletonOperation() {}public static void main(String[] args) {Singleton5 singleton1 = Singleton5.INSTANCE;Singleton5 singleton2 = singleton1.INSTANCE;System.out.println(singleton1 == singleton2);//true}
}

三：反射和反序列化漏洞及其解决方案

1.反射可以破解上面几种实现方式~（不包含枚举式）

示例：通过反射破解静态内部类的单例模式(联系上方静态内部类实现单例模式的代码)

package 设计模式;import java.lang.reflect.Constructor;/*** 避免通过反射破解静态内部类单例模式*/
public class singleProblem1 {public static void main(String[] args) throws Exception {Singleton4 s1 = Singleton4.getInstance();Singleton4 s2 = Singleton4.getInstance();System.out.println(s1);System.out.println(s2);//通过反射直接调用私有构造器Class c = Class.forName("设计模式.Singleton4");System.out.println(c);Constructor constructor = c.getDeclaredConstructor(null);constructor.setAccessible(true);Singleton4 s3 = (Singleton4) constructor.newInstance();Singleton4 s4 = (Singleton4) constructor.newInstance();System.out.println(s3);System.out.println(s4);}
}

根据结果，发现产生了两个新对象，我们的解决方案就是 在私有构造器中手动抛出异常控制，在私有构造器内加入以下代码

解决方法：可以在私有构造器中手动抛出异常控制

//构造器私有private Singleton4() {if (getInstance() != null)throw new RuntimeException();}

 根据实验结果发现，已经无法通过反射用私有构造器创建新的对象！！

解决成功！！！

2.反序列化可以破解上面几种（不包含枚举式）实现方式！

示例：通过反序列化破解静态内部类的单例模式(联系上方静态内部类实现单例模式的代码)

package 设计模式;import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;/*** 避免通过反射破解静态内部类单例模式*/
public class singleProblem1 {public static void main(String[] args) throws Exception {Singleton4 s1 = Singleton4.getInstance();Singleton4 s2 = Singleton4.getInstance();System.out.println(s1);System.out.println(s2);//通过反序列化的的方式构造多个对象//序列化ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("D:/学习/IDEA project/project/src/设计模式/a.txt"));out.writeObject(s1);out.close();//反序列化ObjectInputStream in = new ObjectInputStream(new FileInputStream("D:/学习/IDEA project/project/src/设计模式/a.txt"));Singleton4 s3 = (Singleton4) in.readObject();System.out.println(s3);//如果没有readResolve方法则会构造出一个新对象，破解了单例}
}

根据结果，发现产生了一个新对象，我们的解决方案就是在上方静态内部类实现单例的代码中加入readResolve函数

  解决方法：可以通过定义readResolve()防止获得不同对象。

  反序列化时，如果对象所在类定义了readResolve(),(实际是一种回调），定义返回哪个对象

 //为了防止反序列化破解，添加此方法//如果定义了readResolve方法，则直接返回此方法指定的对象，而不需要再单独创建对象private Object readResolve() {return getInstance();}

根据新的实验结果，我们发现新创建出来的对象与通过单例模式创建出的对象相同，即解决成功！！

四：测试单例模式的效率 

通过一下代码可以测试上述五种方法效率，一下为测试Singleton1，即饿汉式实现单例的时间！！！！

package 设计模式;import java.util.concurrent.CountDownLatch;public class testtime {public static void main(String[] args) throws InterruptedException {long start = System.currentTimeMillis();int threadNum = 10;CountDownLatch countDownLatch = new CountDownLatch(threadNum);for (int i = 0; i < 10; i++) {new Thread(new Runnable() {@Overridepublic void run() {for (int j = 0; j < 100000; j++)Singleton1.getInstance();countDownLatch.countDown();}}).start();}countDownLatch.await();//main线程阻塞，知道计数器变为0，才会继续往下执行long end = System.currentTimeMillis();System.out.println("总耗时:" + (end - start));}
}

其中，很重要的一个类

CountDownLatch

同步辅助类，在完成组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待

在此方法中，在主线程执行后，启动了十个线程 ，其中通过CountDownLatch类 实例化出来的countdownlatch相当于一个计数器，初始化为10，每当一个线程执行完后减一，一直阻塞着主线程，直到这十个线程都执行完毕，则主线程停止阻塞，记录最后的时间end，则end-start即为执行这是个线程所需要的时间！

THE END