学习Java单例模式，小白看这篇就够了！

每天学一点，每天进步一点，质的飞跃需要量的积累，add oil！！！

首先我们学任何一项技术都必须知道其应用的场景，其后我们再去学习它的使用方法

常见应用场景

1. Windows的 Task Manager（任务管理器）就是很典型的单例模式
2. 项目中，读取配置文件的类，一般也只有一个对象。没有必要每次使用配置文件数据，每次new几个对象去读取
3. 网站的计数器，一般也是采用单例模式实现，否则难以同步。
4. 应用程序的日志应用，一般都何用单例模式实现，这一般是由于共享的日志文件一直处于打开状态，因为只能有一个实例去操作，否则内容不好追加
5. 数据库连接池的设计一般也是采用单例模式，因为数据库连接是种数据库资源。
6. 操作系统的文件系统，也是大的单例模式实现的具体例子，一个操作系统只能有一个文件系统
7. Application也是单例的典型应用（ Servlet编程中会涉及到）
8. 在 Spring中，每个Bean默认就是单例的，这样做的优点是 Spring容器可以管理
9. 在 servlet编程中，每个servlet也是单例
10. 在 spring MVC框架中，控制器对象也是单例

总结：只需要一个对象来解决问题时需要单例模式。可能有些不理解，可以在之后的学习慢慢体会

为什么要学单例模式？

单例模式在笔试面试中经常出现，且项目设计也会用到的设计模式。

下面我们就开始学习单例模式的使用，也是本文关键点

常见的五种单例模式实现方式

主要

学习下面两个可以应付一般的笔试面试

饿汉式（线程安全，调用效率高。但是，不能延时加载。）
懒汉式（线程安全，调用效率不高。但是，可以延时加载。）
其他

下面三点是吊打面试官系列，比较难，面试官都可能不知道。学好了面试加分，好好学哦。

双重检测锁式（由于JVM底层内部模型原因，偶尔会出问题。不建议使用）
静态内部类式（线程安全，调用效率高。但是，可以延时加载）
枚举单例（线程安全，调用效率高，不能延时加载，由JVM从根本上提供保障！避免通过反射和反序列化的漏洞）

下面我们逐个击破

饿汉式

顾名思义，饿汉它饥渴，所以…,直接上代码来理解

public class Hungry {
    //饿汉它饥渴，一来就创建女朋友
    //类初始化时，立即加载这个对象女朋友（没有延时加载的优势）。加载类时，天然的是线程安全
    private static Hungry girlfriend = new Hungry();//注意：private，保证只能通过getInstance()方法来创建实例

    private Hungry() {//注意：private，保证只能通过getInstance()方法来创建实例
    }
    //方法没有同步，调用效率高！
    public static Hungry getInstance() {
        return girlfriend;
    }
}

public class Test {
    public static void main(String[] args) {
        Hungry girlfriend1 = Hungry.getInstance();
        Hungry girlfriend2 = Hungry.getInstance();
        System.out.println(girlfriend1 == girlfriend2);//永远是true
    }
}

总结：

• 线程安全：类加载器加载对象是一个天然的线程安全，所以是线程安全的
• 可能造成资源浪费：如果加载了饿汉类，必然会创建女朋友，那如果这个饿汉又没有使用这个女朋友，必然会让其它男生少了一个可以选择的对象，造成资源的浪费

饿汉式单例模代码中， static变量会在类装载时初始化，此时也不会涉及多个线程对象访问该对象的问题。虚拟机保证只会装载一次该类，肯定不会发生并发访问的问题。因此，可以省略 synchronized关键字。问题:如果只是加载本类，而不是要调用 getinstance0，甚至永远没有调用，则会造成资源浪费！

懒汉式

public class LazyMan {
	//懒汉比较懒，没有找女朋友，等有需求了再找
    //类初始化时，不初始化这个对象（延时加载，真正用的时候再创健建）。
    private static LazyMan girlfriend;
    //私有化构造器
    public LazyMan() {
    }
   //方法同步，调用效率低
    public static synchronized LazyMan getInstance(){
        if (girlfriend == null) { //防止重复创建实例
            girlfriend = new LazyMan();
        }
        return girlfriend;
    }
}

public class Test {
    public static void main(String[] args) {
        LazyMan girlfriend1 = LazyMan.getInstance();
        LazyMan girlfriend2 = LazyMan.getInstance();
        
        System.out.println(girlfriend1 == girlfriend2);//true
    }
}

为什么要加synchronized 关键字？

• 假设有A和B两个线程，A线程 执行到if (girlfriend == null) 挂起，此时没有创建对象，在A挂起的时间段内，B线程执行到if (girlfriend == null) ，判断条件成立，创建对象girlfriend ，此时A线程再次开始执行，又创建了一个对象girlfriend ，于是不满足单例模式只创建一个对象的条件。所以我们要在LazyMan 类前加锁。

总结：

• lazy load！延迟加载，懒加载！真正用的时候才加载
• 资源利用率高了。但是，每次调用 getinstance0方法都要同步，并发效率较低

双重检测锁式

public class DoubleCheckLock {
    private static DoubleCheckLock instance = null;

    public static DoubleCheckLock getInstance() {
        if (instance == null) {
            DoubleCheckLock sc;
            synchronized (DoubleCheckLock.class) {
                sc = instance;
                if (sc == null) {
                    synchronized (DoubleCheckLock.class) {
                        if (sc == null)
                            sc = new DoubleCheckLock();
                    }
                }
                instance = sc;
            }
        }

        return instance;
    }
            private DoubleCheckLock(){
        }
}

总结：

• 这方法知道思想即可，实际工作中不会使用
• 这个模式将同步内容下方到内部，提高了执行的效率， 不必每次获取对象时都进行同步，只有第一次才同步，创建了以后就没必要了。
  问题:
• 由于编译器优化原医和JVM底层內部模型原因
• 偶尔会出问题。不建议使用

静态内部类式

其实也可以理解为懒加载，此方法重点掌握，框架也经常使用此方法

public class StaticInnerClass {

    //定义静态内部类，初始化StaticInnerClass时，不会加载静态内部类
    private static class SingletonClassInstance{
        private static final StaticInnerClass instance = new StaticInnerClass();
    }
	//不要同步方法，调用效率高，线程安全且高效
    public static StaticInnerClass getInstance(){
        return SingletonClassInstance.instance;
    }
    private StaticInnerClass() {
    }
}

总结：

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

枚举单例

//使用枚举实现单例模式
public enum EnumSingleton {
    //这个枚举元素，本身就是单例对象
    INSTANCE;
    //添加需要的操作
    public void singletonOperation(){

    }
}

public class Test {
    public static void main(String[] args) {
        System.out.println(EnumSingleton.INSTANCE == EnumSingleton.INSTANCE);//true
    }
}

总结：

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

如何选用最适合的方法？

学习了五种方法之后，那么实际运用中，如何选择合适的方法呢？

当单例对象占用资源少，不需要延时加载时

• 枚举式优于饿汉式

当单例对象占用资源大，需要延时加载时

• 静态内部类式优于懒汉式

Java小白修炼手册