设计模式--单例模式

模式定义；保证一个类只有一个实例，并且提供一个全局访问点。 

应用场景：重量级的对象，不需要多个实例，如线程池，数据库连接池。就是被复用的。。

懒汉模式，饿汉模式，静态内部类，反射攻击实例，枚举，序列化

懒汉：延迟加载，

public class LazySingletonTest {
    public static void main(String[] args) {
        //单线程
//        LazySingleton instance=LazySingleton.getInstance();
//        LazySingleton instance1=LazySingleton.getInstance();
//        System.out.println(instance==instance1);
        //两个线程
        new Thread(()->{
            LazySingleton instance=LazySingleton.getInstance();
            System.out.println("instance = " + instance);
        }).start();
        new Thread(()->{
            LazySingleton instance=LazySingleton.getInstance();
            System.out.println("instance = " + instance);
        }).start();
    }
    /**instance = danli.LazySingleton@437d73bc
       instance = danli.LazySingleton@2ea7cb0b
     这是加synchronize之前，加上之后，只会出现相同的结果*/
}
class LazySingleton {
    private volatile static LazySingleton instance;
    private LazySingleton(){

    }
    //提供全局的访问点
    //当调用instance的时候，才会实例化
    public synchronized  static LazySingleton getInstance() {
        if (instance == null){
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            instance=new LazySingleton();
        }
        return instance;
    }
}
加锁的作用，就i是为了保证只new 一个实例，但是加syn就是不管有没有初始化都会加锁，但是当instance！=null的时候
是不需要加锁的，直接返回

if (instance == null){
    //但是当两个线程都没有实例的时候，就会都进去实例化，
    // 所以就是两个线程都会实例化,所以要再判断一下
    synchronized (LazySingleton.class){
        if (instance == null) {
            instance=new LazySingleton();
        }
    }
}
return instance;
new 会在堆空间，开辟一块空间。CPU会有即时编码，有指令重拍。1、分配空间2、初始化3、引用赋值。2，3可以倒，但是不影响运行
volatile会保证Java命令顺序执行，不会出现指令重排现象。
 private volatile static LazySingleton instance;

 延迟加载，在使用的时候，进行加载。要注意的情况：

1）多线程情况下，线程安全问题，可以syn解决一些

2）double check 加锁进行优化

3）还要防止Java的即时编码（JIT）,CPU有可能出现的指令重排，导致使用到没有初始化的实例，加volatile关键字。

饿汉模式---

public class HungrySingletonTest {
    public static void main(String[] args) {
        //new HungrySingleton();这样不能保证单例
        HungrySingleton instance=HungrySingleton.getInstance();
        HungrySingleton instance1=HungrySingleton.getInstance();
        System.out.println(instance==instance1);
    }
}
//饿汉模式
// 主要是通过类加载机制，
/**1、加载二进制数据到内存，生成对应的class数据结构
 * 2、连接：a.验证b.准备（给类的静态成员变量赋默认值）c.解析
 * 3、初始化：给类的静态变量赋初值
 * 在类加载的时候，是在类被调用的时候，*/
class HungrySingleton{

    private static HungrySingleton instance=new HungrySingleton();
//私有构造函数，保证在外部不能实例化，只要是为了保证单例
    private HungrySingleton() {
    }
        //提供公开的方法，以便访问
    public static HungrySingleton getInstance(){
        return instance;
    }
}
静态内部类:

public class InnerClassSingletonTest {
    public static void main(String[] args) {
//        InnerClassSingleton instance=InnerClassSingleton.getInstance();
//        InnerClassSingleton instance1=InnerClassSingleton.getInstance();
//        System.out.println(instance==instance1);
        //多线程
        new Thread(()->{
            InnerClassSingleton instance=InnerClassSingleton.getInstance();
            System.out.println("instance = " + instance);
        }).start();
        new Thread(()->{
            InnerClassSingleton instance=InnerClassSingleton.getInstance();
            System.out.println("instance = " + instance);
        }).start();
    }
}
class InnerClassSingleton{
    private static class InnerClassHolder {
        /**在静态内部类进行属性的初始化,也算是懒加载，不使用的时候，不会实例化*/
        private static InnerClassSingleton instance=new InnerClassSingleton();
    }
    /**提供私有的构造函数，就能保证别人不能再外部访问*/
    private InnerClassSingleton(){
    }
    public static InnerClassSingleton getInstance(){
        return InnerClassHolder.instance;
    }
}
原理：
1）本质上是利用类的加载机制来保证线程安全
2）只有在实际中使用的时候，才会触发类的初始化，所以也是一种懒加载。
反射攻击实例：

 public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
//反射，，，静态，还有懒汉模式
        //这是拿到构造函数
        Constructor<InnerClassSingleton> declaredConstructor = InnerClassSingleton.class.getDeclaredConstructor();
        //这里是拿到访问权，就算是private修饰也可以取到
        declaredConstructor.setAccessible(true);
        //然后进行实例化
        InnerClassSingleton innerClassSingleton = declaredConstructor.newInstance();

        InnerClassSingleton instance = InnerClassSingleton.getInstance();
//这里的结果是false。
        System.out.println(instance==innerClassSingleton);
    }
}

静态和饿汉都可以被反射进行攻击，所以要加防护，，，，懒汉不能保证

/**提供私有的构造函数，就能保证别人不能再外部访问*/
private InnerClassSingleton(){
    if (InnerClassHolder.instance!=null){
        throw  new RuntimeException("报错，instance已经初始化，单例不允许多个实例");
    }
}
保证其他地方不能用反射的方式进行多例的实例化。

枚举举例：
1）天然不支持反射创建对应的实例，且有自己的反序列化机制
2）利用类加载机制保证线程安全

public enum  EnumSingleton {
    INSTANCE;
    public void print(){
        System.out.println(this.hashCode());
    }
}
class EnumTest{
    public static void main(String[] args) {
        EnumSingleton instance=EnumSingleton.INSTANCE;
        EnumSingleton instance1=EnumSingleton.INSTANCE;
        //结果为true
        System.out.println(instance== instance1);
    }
}

//可以设置参数，一个string类型，一个int类型
Constructor<EnumSingleton> declaredConstructor = EnumSingleton.class.getDeclaredConstructor(String.class,int.class);
//这里进行访问权设置，private修饰的都可以
declaredConstructor.setAccessible(true);
//为什么设置这两个参数，底层要继承Enum抽象类（里面的参数为name，int），
EnumSingleton instance = declaredConstructor.newInstance("INSTANCE", 0);
这个方法报错，不支持enum类型的对象创建。所以用enum是可以进行单例的创建，不会被反射使用，也是线程安全的

序列化：

implement Serializable，，
当用流进行时，writeOutFile和ObijectInputStream得到的结果并不是一样的。可以加版本号，然后就可以控制内容保持一致。