☺ 对于单例模式，个人学习需要掌握

• 注意答案的重点标黑了。对于单例模式，掌握，我下面这几点就很棒棒。

1、知道什么是单例：

答：一个类有且仅有一个实例，[单例]，单例模式保证了系统内存中该类只存在一个对象，节省了系统资源，对于一些需要频繁创建销毁的对象，使用单例模式可以提高系统性能。实例化对象的时候，是通过相应的方法，而不是直接new

2、单例模式的意义：节省系统资源

答：[一个类仅仅有一个唯一的对象，并且提供一个全局的访问点]，节省系统资源。具体场景：例如公共的全局配置。

公共的全局配置在系统运行时候，就需要加载一些配置和属性，这些配置和属性是一定存在了，又是公共的，同时需要在整个生命周期中都存在，所以只需要一份就行，使用单例模式实现。

3、单例模式的使用场景

答：需要频繁的进行创建和销毁的对象、经常用到的重量级对象(创建对象时耗时很多或耗费资源很多)、工具类对象、频繁访问数据库或文件的对象(比如数据源、session工厂等）

4、单例模式的方式

• 个人需要掌握：很简单的饿汉式(静态常量/静态代码块)、懒汉式(双重检查)、静态内部类
• 了解开发中推荐使用的模式是饿汉式(静态常量/静态代码块)、双重检查 (懒汉式的改良实用版)、 静态内部类、 枚举方式
• 在掌握双重检查的时候，可以先了解一下不推荐在开发使用的懒汉式的三种情况(线程不安全、线程安全[同步方法]、线程安全[同步代码块])
• 面试写单例模式[饿汉、懒汉]的话，就写写饿汉式(静态常量/静态代码块)、懒汉式(双重检查[懒汉式的改良实用版])

5、单例模式利用了jvm的特点[在静态内部类的模式中]

■ 静态内部类优缺点:(利用了jvm的两个特点，起到了懒加载、线程安全的作用)

• 懒加载：利用了jvm装载的特点：当外部类加载的时候，内部静态类不会被加载，从而保证了懒加载。
• 线程安全：当类在进行初始化的时候，别的线程是无法进入的。通过类的静态属性只会在第一次加载类的时候初始化，保证了线程安全。

一、什么是单例模式：

在java中的定义是：一个类有且仅有一个实例，[单例]，并且自行实例化向整个系统提供。

(1) 单例模式保证了系统内存中该类只存在一个对象，节省了系统资源，对于一些需要频繁创建销毁的对象，使用单例模式可以提高系统性能

(2) 当想实例化一个单例类的时候，必须要记住使用相应的获取对象的方法，而不是使用new

二、实现单例的步骤：

1、构造器私有化，防止new，导致多个实例，而是在类内部创建对象

2、向外暴露一个静态的公共方法 getInstance

三、单例的方式

■ 单例模式有八种方式：

饿汉式(静态常量/静态代码块)

懒汉式(线程不安全/线程安全，同步方法/线程安全，同步代码块)

双重检查

静态内部类

枚举

★ 饿汉式和懒汉式区别：

饿汉式：在类内部一开始初始化时就创建好实例，而懒汉式是需要用的时候才去创建实例

■ 饿汉式(静态常量/静态代码块)

在开发中推荐使用，尤其是该类的实例会用到，避免了造成内存的浪费，如果该类的实例不用，则会造成内存的浪费。

/**
* 饿汉式(静态常量)
*/
public class Singleton{
    private static final Singleton singleton  = new Singleton();//饿汉式，初始化时就创建好了实例[使用了final常量-->饿汉式(静态常量)]
    private Singleton(){}//构造器私有化，防止new，导致多个实例
    public static Singleton getInstance(){//向外暴露一个静态的公共方法  getInstance
        return singleton;
    }
}

/**
* 饿汉式(静态代码块)
*/
public class Singleton{
    private static Singleton singleton;//饿汉式，初始化时就创建好了实例
    //代码块[使用了static代码块-->饿汉式(静态代码块)]
    static{
        singleton = new Singleton();
    }
    private Singleton(){}//构造器私有化，防止new，导致多个实例
    public static Singleton getInstance(){//向外暴露一个静态的公共方法  getInstance
        return singleton;
    }
}

■ 饿汉式(静态常量) 和 饿汉式（静态代码块) 的优点、缺点：相同

□ 优点：实现较为简单，在类加载时就完成了实例化，避免了多线程同步问题

□ 缺点：在类加载时就完成了实例化（使类加载的情况有很多种，不一定是调用getInstance()方法使类进行加载的），没有达到懒加载的效果。如果程序从始至终未用到该实例，则造成了空间浪费

■ 懒汉式(线程不安全/ 线程安全，同步方法 / 线程安全，同步代码块)

□ 懒汉式(线程不安全)

public class Singleton{
    private Singleton(){}//构造器私有化，防止new，导致多个实例
    private static Singleton singleton;
    public static Singleton getInstance(){//向外暴露一个静态的公共方法  getInstance
        if(singleton == null){
            singleton = new Singleton();
        }
        return singleton;
    }
}

■ 懒汉式(线程不安全) 优缺点：起到懒加载的效果，但是只适合在单线程下使用（开发中不推荐使用）

□ 线程不安全原因：如果在多线程下，一个线程进入了if (singleton == null)判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。所以在多线程环境下不可使用这种方式

□ 懒汉式(线程安全，同步方法)

public class Singleton{
    private Singleton(){}//构造器私有化，防止new，导致多个实例
    private static Singleton singleton;
    //同步方法，synchronized直接加在方法上
    public static synchronized Singleton getInstance(){//向外暴露一个静态的公共方法  getInstance
        if(singleton == null){
            singleton = new Singleton();
        }
        return singleton;
    }
}

■ 懒汉式(线程安全，同步方法) 优缺点：起到懒加载的效果，线程安全，但是调用效率低（开发中不推荐使用）

□ 懒汉式(线程安全，同步代码块)

public class Singleton{
    private Singleton(){}//构造器私有化，防止new，导致多个实例
    private static Singleton singleton;
    public static Singleton getInstance(){//向外暴露一个静态的公共方法  getInstance
        if(singleton == null){
            //同步代码块，synchronized是单独作为代码块使用
            synchronized (Singleton.class){
                singleton = new Singleton();
            }     
        }
        return singleton;
    }
}

■ 懒汉式(线程安全，同步代码块) 优缺点：起到懒加载的效果，但是只适合在单线程下使用（开发中不推荐使用）

□ 线程不安全原因：和 □ 懒汉式(线程不安全)一样。

■ 双重检查

public class Singleton{
    private Singleton(){}//构造器私有化，防止new，导致多个实例
    private static volatile Singleton singleton;
    public static Singleton getInstance(){//向外暴露一个静态的公共方法  getInstance
        //第一层检查
        if(singleton == null){
            //同步代码块
            synchronized (Singleton.class){
                 //第二层检查
                if(singleton == null) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

双重检查优缺点：解决了同步代码块方式的线程安全问题。

其实就是上面的 □ 懒汉式(线程安全，同步代码块)的优化改良版。

■ 静态内部类

public class Singleton{
    private Singleton(){}//构造器私有化，防止new，导致多个实例
    //静态内部类,在其内部以静态常量的方式实例化对象
    private static class SingletonInstance{
        private static final Singleton singleton = new Singleton();//常量静态属性，实例化对象[初始化]
    }
    public static Singleton getInstance(){//向外暴露一个静态的公共方法  getInstance
        return SingletonInstance.singleton;
    }
}

■ 静态内部类优缺点:(利用了jvm的两个特点，起到了懒加载、线程安全的作用)

• 懒加载：利用了jvm装载的特点：当外部类加载的时候，内部静态类不会被加载，从而保证了懒加载。
• 线程安全：当类在进行初始化的时候，别的线程是无法进入的。通过类的静态属性只会在第一次加载类的时候初始化，保证了线程安全。

1.当外部类 Singleton被装载时，静态内部类 SingletonInstance不会被立即装载，实现懒加载

2.当外部类 Singleton调用getInstance()时，静态内部类 SingletonInstance只被装载一次，在初始化静态内部类SingletonInstance的静态常量属性 singleton，保证了线程安全。

■ 枚举方式

enum Singleton{
    INSTANCE;
    public void method(){
//            操作方法
    }
}

■ 枚举方式优缺点: 线程安全，效率高，还可防止反序列化重新创建新的对象.

四、单例的使用场景

需要频繁的进行创建和销毁的对象、

创建对象时耗时过多或 耗费资源过多(即：重量级对象)，但又经常用到的对象、工具类对象、频繁访问数据库或文件的对象(比如数据源、session工厂等）

参考内容来源：《尚硅谷Java设计模式（图解+框架源码剖析）》 https://www.bilibili.com/video/BV1G4411c7N4

如果本文对你有帮助的话记得给一乐点个赞哦，感谢！