一、为什么使用单利模式
在讲单利模式之前，我们待想一个问题，我们为什么要使用单利模式呢？
单利：表面的意思就是一个类只能存在一个实例，那我们什么时候会用到单利模式呢？最常见的有以下几种场景：
1、Windows的Task Manager（任务管理器）就是很典型的单例模式
2、项目中，读取配置文件的类，一般也只有一个对象。没有必要每次使用配置文件数据，每次new一个对象去读取。
3、数据库连接池的设计一般也是采用单例模式，因为数据库连接是一种数据库资源。
4、在Spring中，每个Bean默认就是单例的，这样做的优点是Spring容器可以管理 。
5、在servlet编程中/spring MVC框架，每个Servlet也是单例 /控制器对象也是单例.
综上所述单利有两个好处：
1、节省内存
2、方便管理
二、单利模式的定义及特点
单例（Singleton）模式的定义：指一个类只有一个实例，且该类能自行创建这个实例的一种模式。
单例模式有 三个特点：
1、类只有一个实例对象；
2、该单例对象必须由单例类自行创建；
3、类对外提供一个访问该单例的全局访问点；
三、单利模式的实现方式
我们实现单利模式主要抓住三个特点：
1、将构造函数私有化
2、在类的内部创建实例
3、提供获取唯一实例的方法
1、饿汉式实现单利
该模式的特点是在类加载时没有创建实例，只有第一次调用方法getInstance()时才会创建单利对象，具体代码如下：
/**
* 懒汉式单利模式（线程安全，调用效率不高，但是，可以实现延时加载）
*/
public class SingletonL {
private static volatile SingletonL instance = null;
private SingletonL() { //避免类在外部被实例化
}
//创建对象的外部方法
public static synchronized SingletonL getInstance() {
if (null == instance) {
instance = new SingletonL();
}
return instance;
}
}
说明：如果我们在编写多线程的程序就需要关键字 volatile 和 synchronized，能保证线程安全，但是每次访问时都要同步，会影响性能，且消耗更多的资源，这是懒汉式单例模式的缺点。
2、饿汉式模式
该模式的特点在类加载的时候就创建对象，在调用getInstance()是对象已经存在。
/**
* 饿汉式单利模式（线程安全，调用效率高，但是，不可以延时加载）
*/
public class SingletonE implements Serializable {
//防止被引用
private static SingletonE instance = new SingletonE();
//防止被实例化
private SingletonE() {
}
public static SingletonE getInstance() {
return instance;
}
}
说明饿汉式单例模式代码中，static变量会在类装载时初始化，此时也不会涉及多个线程对象访问该对象的问 题。虚拟机保证只会装载一次该类，肯定不会发生并发访问的问题。
3、静态内部类
该模式的特点是通过一个静态内部类创建实例对象，然后调用getInstance()实现单利，是线程安全的
/**
* 静态内部类单利模式（线程安全，调用效率高。 但是，可以延时加载）
*/
public class SingletonJt {
private static class staticFactory {
private static final SingletonJt instance = new SingletonJt();
}
//防止被实例化
private SingletonJt() {
}
public static SingletonJt getInstance() {
return staticFactory.instance;
}
}
说明外部类没有static属性，则不会像饿汉式那样立即加载对象，只有真正调用getInstance(),才会加载静态内部类。加载类时是线程 安全的。instance是static final 类型，保证了内存中只有这样一个实例存在，而且只能被赋值一次，从而保证了线程安全性 。
4、枚举单利
/**
* 枚举单利模式（线程安全，调用效率高，不能延时加载）
*/
public enum Singletonenum {
INSTANCE;
}
public class Client {
public static void main(String[] args) {
Singletonenum singletonenum=Singletonenum.INSTANCE;
Singletonenum singletonenum1=Singletonenum.INSTANCE;
System.out.println(singletonenum==singletonenum1);
}
}
说明枚举本身就是单利模式，不可以实现延时加载。
四、单例模式的效率安全问题
两种方式实现懒汉模式的安全问题：
1、反射
2、序列化和反序列化
通过反射中的setAccessible(true)方法,破解懒汉式单利模式，具体代码如下：
/**
* 测试懒汉式单利模式（反射）
*/
public static void testSingleLFs() throws Exception {
Class c= Class.forName("com.designpattern.pattern.singletonpattern.SingletonL");
Constructor constructor=c.getDeclaredConstructor(null);
constructor.setAccessible(true);
SingletonL singletonL1=(SingletonL) constructor.newInstance();
SingletonL singletonL11=(SingletonL) constructor.newInstance();
System.out.println(singletonL1==singletonL11); //返回为false
}
那我们如何避免这个问题呢?只需要在在单利模式中加入这段代码即可：即在私有构造器中加一个判断规则即可实现，System.out.println(singletonL1==singletonL11); //返回为true
private SingletonL() { //避免类在外部被实例化
if (null==instance){
throw new RuntimeException("实例已经存在");
}
}
通过序列化和反序列化破解单利模式，思路是先把实例的对象写到一个文件当中，然后在读到程序当中，具体代码如下：
/**
* 测试懒汉式单利模式（序列化和反序列化）
* @param singletonL
* @throws Exception
*/
public static void testSingleLxL(SingletonL singletonL) throws Exception {
ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("D:/a.txt"));
oos.writeObject(singletonL);
oos.close();
ObjectInputStream objectInputStream=new ObjectInputStream(new FileInputStream("D:/a.txt"));
System.out.println((SingletonL)objectInputStream.readObject());
}
避免这个问题的方式是在懒汉式单利模式中加入一段代码即可：
//反序列化时，如果定义了readResolve()则直接返回此方法指定的对象。而不需要单独再创建新对象！
private Object readResolve() throws ObjectStreamException {
return instance;
}
单利模式实现方式的效率问题，说明几点：我们需要借助这个类
CountDownLatch – 同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一 个或多个线程一直等待。
• countDown() 当前线程调此方法，则计数减一
• await()， 调用此方法会一直阻塞当前线程，直到计时器的值为0
具体代码如下：
/**
* 测试单利模式的效率
*/
public class ClientTest {
public static void main(String[] args) throws InterruptedException {
long start = System.currentTimeMillis();
int count = 10;
final CountDownLatch countDownLatch=new CountDownLatch(count);
for (int j = 0; j < count; j++) { //多线程环境下
new Thread(new Runnable() {
public void run() {
for (int i = 0; i < 10000; i++) {
//测试那种实现方式修改这里即可
SingletonL singletonL = SingletonL.getInstance(); //测试懒汉式
}
countDownLatch.countDown();
}
}).start();
}
countDownLatch.await(); //main线程阻塞，直到计数器变为0，才会继续往下执行！
long end = System.currentTimeMillis();
System.out.println("总耗时："+(end-start));
}
}
五、小结
常见的单利模式实现方式
主要：
饿汉式：(线程安全，调用效率高，但是，不可以实现延时加载)
懒汉式：（线程安全，调用效率不高，但是，可以实现延时加载）
静态内部类式：（线程安全，调用效率高，但是，可以延时加载）
枚举式：（线程安全，调用效率高，但是，不可以实现延时加载）
选用方式：
单利对象 占用资源少，不需要延时 枚举好于饿汉式
单利对象 占用资源大需要延时加载，静态内部类好于懒汉式
每天进步一丢丢
完成。