单例模式

定义：
一个类模板，在整个系统运行过程中，只允许产生一个实例（配置文件。工厂本身，日历）
**作用：**解决一个并发访问线程安全问题

初衷为了是资源共享。只需赋值一次或初始化一次，大家都能重复利用

应用场景： Listener监听器，日历IOC容器，配置信息Config

技术方案： 保证整个运行过程只有一个

**解决问题：**恶劣环境（程序健壮性）

保障单例技术方案：

饿汉式，懒汉式，注册登记式（枚举式），反序列如何保证单例

饿汉式：

实例使用前实例化，避免了线程安全问题
**优点：**没有任何锁，执行效率高，用户体验比懒汉好，
**缺点：**类加载就初始化，不管是不是用都占用空间，可能浪费内存

懒汉式：

默认时不用，使用时new（延时加载）
外部类被调用的时候才会加载内部类

package lazy;
/*单例
特点：内部类只有在外部类调用时才会被加载
内部类一定是要在方法调用之前初始化
巧妙避免线程安全问题

* 兼顾了饿汉式内存浪费，也兼顾了synchronized性能问题
* 完美屏蔽了两个缺点
* 最完美单例方式
*
* 巧妙利用了内部类
* */
public class LazyThree {
//防止反射侵入
        private static boolean inintial =false;
        //默认使用LazyThree时，会先初始化内部类，如果没使用内部类，内部类不会加载
        private LazyThree() {
            synchronized (LazyThree.class){
                if(inintial==false){
                    inintial=!inintial;
                }else {
                    throw new RuntimeException("单例已被侵犯");
                }
            }
        }
//防止反射侵入        
    
        /*static为了使单例空间共享
        final保证方法不会被重写重载*/
        public static final LazyThree getInstance(){
            /*if (lazyThree ==null){
                LazyThree lazyThree =new LazyThree();
            }
            return lazyThree;*/
            return LazyHolder.LAZY;
        }
        //静态内部类
        public static class LazyHolder{
            private static final LazyThree LAZY=new LazyThree();
        }
    
    }

注册登记式：

每使用一次都往一个固定容器中注册并将使用过的对象进行缓存，下次去对象直接从缓存中取出，以保证每次获取都是同一个对象，（枚举式、IOC单例模式是典型注册登记模式）

package register;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

public class BeanFactory {
    private BeanFactory() {
    }
    private static Map<String,Object> ioc=new ConcurrentHashMap<>();
    public static synchronized Object getBean(String className){
        //控制线程安全
        if(!ioc.containsKey(className)){
            Object obj=null;
            try {
                obj=Class.forName(className).newInstance();
                ioc.put(className,obj);
            } catch (Exception e) {
                e.printStackTrace();
            }
            return obj;

        }else {
            return ioc.get(className);
        }
    }
}

序列化与反序列化保证单例问题解决方案：重写readResolve()

  package seriable;

import java.io.Serializable;

public class Seriable implements Serializable {
    //序列化就是把内存中的状态通过转换，变成字节码形式
    //从而转换一个IO留，写入到其他地方，可以是磁盘网络IO流
    //内存中状态就被永久保存下来了（整个过程叫持久化）
//反序列化 ，将已经持久化的字节码内容转换为IO流
//进而通过IO流的读取，将读取的内容转化成JAVA对象，
//转换过程中会重新new对象
private Seriable() {
}
public static final Seriable INSTANCE=new Seriable();
public  static Seriable getInstance(){
    return INSTANCE;
}
//重写readResolve转换过程中不会重新new对象，保证单例
private Object readResolve(){
    return INSTANCE;
}

}