懒汉模式，饿汉模式，以及懒汉模式在内部类，序列化机制和枚举中的实例

懒汉模式在序列化机制中的实例

import java.io.*;

/**
 * およそ神
 * 懒汉模式
 * 序列化机制
 */
public class LazyTest {
    public static void main(String[] args) {
        //序列化过程
        Lazy lazy = Lazy.getInstance();
        /*try (ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("test"))){
        objectOutputStream.writeObject(lazy);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }*/
        try (ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("test"));){
            try {
                Lazy lazy1 = (Lazy) objectInputStream.readObject();
                System.out.println(lazy1==lazy);//是否和序列化的是同一个对象false
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
//实现一个接口Serializable接口为空，但是不实现这个接口就会报异常
class Lazy implements Serializable {
    //提供一个固定的版本号，解决兼容性问题
    private static final long serialVersionUID = -3372123889599862014L;
    //volatile防止指令重排
    private volatile static Lazy instance;

    private Lazy() {

    }
    //synchronized锁解决两个线程同时访问
    public  static Lazy getInstance() {
        if (null == instance) {
            //如果两个线程同时进入的话就会产生两个实例
            synchronized (Lazy.class) {
                if (null == instance) {
                    instance = new Lazy();
                    //1.开辟空间
                    //3.给Lazy赋值
                    //2.完成初始化
                }
            }
        }
        return instance;
    }
    Object writeReplace() throws ObjectStreamException{
        return getInstance();
    }
}

懒汉模式在内部类中的实例

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

/**
 * およそ神
 * 内部类
 * 反射创建
 */
public class InnerClassTest {
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        //System.out.println(Inner.name);
        System.out.println(Inner.getInstance());//两个都会输出！
        Constructor<Inner> declaredConstructor = Inner.class.getDeclaredConstructor();
        //访问权设置为公开
        declaredConstructor.setAccessible(true);
        //new多少个就会创建多少个实例
        Inner inner = declaredConstructor.newInstance();
        Inner instance = Inner.getInstance();
        System.out.println(inner==instance);
    }
}

/**
 * 静态内部类，饿汉模式是基于jvm加载机制，不过是哪个线程来访问都要保证一点就是：
 * 当前已经加载好了
 */
class Inner {
    public static String name = "fan !";
    static{
        System.out.println("InnerClass !");//1
    }

    private static class SingHolder {
        static{
            System.out.println("SingHolder !");//2
        }
        private static Inner instance = new Inner();
    }
    private Inner() {
        if (SingHolder.instance != null) {
            throw new RuntimeException("单例不允许多个实例！");
        }
    }

    public static Inner getInstance() {
        return SingHolder.instance;
    }
}

懒汉模式在枚举中的实例

/**
 * およそ神
 * 枚举(本质上就是饿汉模式)
 */
public class EnumSingTest {
    public static void main(String[] args) {
        EnumSing instance = EnumSing.INSTANCE;
        instance.doBiz();
        //同一个实例
        EnumSing instance1 = EnumSing.INSTANCE;
        instance1.doBiz();
    }
}
//iconst_0
enum EnumSing {
    INSTANCE;
    public void doBiz() {
        System.out.println(hashCode());
    }

}

饿汉模式

/**
 * およそ神
 * 饿汉模式
 */
public class HungryTest {
    public static void main(String[] args) {
        Class<Hungry> hungryClass = Hungry.class;
        //System.out.println(Hungry.name);
        Hungry.print();
    }
}

class Hungry {
    //访问属性或者调用方法都会触发初始化instance
    public static String name = "fan";
    static {
        System.out.println("Hungry !");
    }
    //类在加载的过程中就自动帮助初始化了instance
    private static Hungry instance = new Hungry();

    private Hungry() {

    }
    public static Hungry getInstance() {
        return instance;
    }
    public static void  print() {
        System.out.println("fanzongshen !");
    }
}