饿汉式

//饿汉式(没有线程安全问题) 存在暴力反射，序列化和反序列化问题
public class SingleTon1 {
    private static final SingleTon1 singleton = new SingleTon1();

    //私有构造方法
    private SingleTon1() {

    }

    //提供公有访问方法
    public static SingleTon1 getInstance() {
        return singleton;
    }
}

懒汉式（double check）

/**
 * 懒汉式 双重检查double check模式
 * 没有线程安全问题 存在暴力反射、序列化问题
 */
public class SingleTon2 {
    //volatile关键字作用：防止指令重排
    private volatile static SingleTon2 instance = null;

    public static SingleTon2 getInstance() {
        if (instance == null) {
            synchronized (SingleTon2.class) {
                if (instance == null) {
                    instance = new SingleTon2();
                }
            }
        }
        return instance;
    }
}

volatile关键字作用：

1、线程可见性（更新内存）

2、volatile不能保证原子性  synchronized可以保证原子性  使用CAS可以实现原子性

3、volatile防止指令重排  volatile 可以禁止指令的重排序，保证多线程环境内的系统安全

静态内部类单例模式

/**
 * 静态内部类单例模式
 * 没有线程安全问题 存在暴力反射、序列化问题
 */
public class SingleTon3 {
    private SingleTon3() {

    }

    static class InnerClass {
        public static SingleTon3 singleTon = new SingleTon3();
    }

    public static SingleTon3 getInstance() {
        return InnerClass.singleTon;
    }
}

静态代码块单例模式

/**
 * 静态代码块单例模式
 * 没有线程安全问题 存在暴力反射、序列化问题
 */
public class SingleTon4 {
    static SingleTon4 singleTon = null;

    private SingleTon4() {

    }

    static {
        singleTon = new SingleTon4();
    }

    public static SingleTon4 getInstance() {
        return singleTon;
    }
}

枚举单例模式（单例模式最优解）

/**
 * 枚举单例模式
 * （最好的单例设计模式）
 * 没有线程安全问题 不能暴力反射（底层会抛异常） 反序列化是同一对象
 */
public enum SingleTon5 {
    INSTANCE;

    private SingleTon5(){
        System.out.println("私有构造方法");
    }

    private int name;

    public int getName() {
        return name;
    }

    public void setName(int name) {
        this.name = name;
    }

    public void fun(){
        System.out.println("测试fun");
    }
}