1.什么是单例模式
2.单例模式的分类及其注意事项
1.什么是单例模式
简单说单例模式就是一个类始终只有唯一的一个对象，无法创建多个对象
为什么要有单例模式，也就是不能创建多个对象，是为了解决资源浪费，数据混乱，状态不一致等问题，数据混乱比如不同的对象中，有一个对象对数据进行了修改，其他对象不一定能同步，可能会继续使用旧值，状态不一致常见登录状态，登录状态无法保持全局一致
2.单例模式的分类
单例模式分为饿汉模式和懒汉模式---------实现单例模式的关键就在于构造方法私有化
（1）饿汉模式
java
public class Singleton {
//final防止二次赋值
//static修饰变为类属性，类加载就会被创建
private final static Singleton instance = new Singleton();//类加载就创建实例
public static Singleton getInstance(){
return instance;
}
private Singleton(){
}
public static void main(String[] args) {
Singleton s1 = Singleton.getInstance();
Singleton s2 = Singleton.getInstance();
System.out.println(s1 == s2);
}
}饿汉模式就是非常饥渴，上来不管三七二十一先把对象创建了再说，哪怕你暂时用不到
那么就会出现问题，
1.1 浪费，而且如果初始化的对象数据庞大，那么将降低效率
1.2 无法延迟加载，比如你的项目原本要依赖某些配置文件，但还未配置好就加载项目了，会造成bug
但是饿汉模式天然线程安全，只涉及到读的操作
（2）懒汉模式
需要创建对象时才会实例化，涉及到条件判定+赋值的操作，因此懒汉模式会造成线程不安全问题
懒汉优点：支持懒加载，节省内存，适合大对象初始化
懒汉模式的线程不安全就在于首次创建对象时会产生线程不安全
需要注意三点
1.加锁
2.避免无效加锁
3.指令重排序问题
java
public class SingletonLazy {
//添加volatile避免指令重排序
private volatile static SingletonLazy instance = null;//类加载时并不会创建对象
/*//懒汉模式的关键在于，把实例化的创建时机推迟，推迟到第一次使用才创建
public static SingletonLazy getInstance(){
//进来先判断是否创建过，没创建过就创建，已经创建过就返回之前的
if(instance == null){
//但这里if判断与进来后赋值存在线程不安全的问题，这两者不是原子的，虽然说两个线程错开来创建了对象，
// 最后真正的对象是其中一个线程的最后赋值指令，另外一个线程创建的对象没有被引用会被自动回收，
// 但存在的问题在于如果对象构造加载的数据非常大呢？就相当于加载了多余的一份数据
instance = new SingletonLazy();
}
return instance;
}*/
/*public static Object object = new Object();
public static SingletonLazy getInstance(){
//这样一进入方法就加锁，加锁太多次了，效率低
synchronized (object){
if(instance == null){
instance = new SingletonLazy();
}
}
return instance;
}*/
public static Object object = new Object();
public static SingletonLazy getInstance(){
//这里判断是否要加锁
if(instance == null){
synchronized (object){
//这里判定是否要实例化
if(instance == null){
instance = new SingletonLazy();
}
}
}
return instance;
}
//单例模式的主要点在于不能让构造方法被调用，所以构造方法得设置为私有的
private SingletonLazy(){
}
public static void main(String[] args) {
SingletonLazy s1 = SingletonLazy.getInstance();
SingletonLazy s2 = SingletonLazy.getInstance();
System.out.println(s1 == s2);
}
}1.加锁：由于判断和赋值不是原子的，加上CPU的随机调度，必然会产生线程不安全，所以要使用synchronized对这两个操作进行加锁，把他们变为原子的
2.避免无效加锁，就像上述代码，虽然已经进行了加锁，但每次需要获取到唯一对象时，只要一进入getinstance方法就会无脑加锁，要加锁又要解锁，开销大，降低效率，所以我们要再加上一个条件，进入这个方法时就要判断有没有实例化过对象，如果实例化过了就跳过这个加锁的过程，直接返回对象即可
所以我们能不加锁就不要加锁
3.指令重排序问题
指令重排序和内存可见性一样，都属于编译器优化的一种手段：调整指令执行的顺序，从而提高代码效率
就拿代码中的赋值对象语句： instance = new SingletonLazy（）来说
它还能细分为三小步
（1）分配内存空间
（2）针对空间进行初始化
（3）内存空间首地址，赋值到引用变量中
正常来讲顺序为123 但由于指令重排序，可能会变为132，那么最后拿到的却是被初始化的对象，也就是一个null，相当于方便面先封口，再去装调料包，那么最后得到的是一包没有调料包的方便面
所以我们避免这个情况，使用volatile来对instance进行修饰，告诉编译器，对instance进行操作时，不需要对其进行优化