定义：
一个类模板，在整个系统运行过程中，只允许产生一个实例（配置文件。工厂本身，日历）
**作用：**解决一个并发访问线程安全问题
初衷为了是资源共享。只需赋值一次或初始化一次，大家都能重复利用
应用场景： 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;
}
}