java 单例模式

懒汉式[最不好的一种]
线程不安全

/**
 * 懒汉式单列
 * 因为对象是在每一次调用的时候创建的.但如果是多线程状态下.多个线程同时执行到第19行时,每个线程都拿到一个空值.
 * 此时就会创建三个对象出来.所以懒汉式的方式是线程不安全的
 */
public class Demo1 {
    private Demo1(){
    }
    private static Demo1 instance = null;

    public static Demo1 getInstance(){
        if (instance == null){
            instance = new Demo1();
        }
        return instance;
    }
}

饿汉式 [线程不安全,用之前一定要确认该对象一定会用到,不然创建了不用就浪费资源]

/**
 * 饿汉式单列
 * 因为对象是类在加载的时候就创建的,所以这个对象始终只会存在一个.
 * 线程安全
 * 不足:如果构造方法中需要大量的处理一些数据.那么会导致这个类在加载的时候特别的慢.从而引起性能问题
 * 所以在使用饿汉模式的时候需要注意以下几点:
 * 1 : 构造方式中没有过多的处理
 * 2 : 该对象一定会被调用.否则会浪费资源
 */
public class Demo2 {
    private Demo2(){

    }
    private static Demo2 instance = new Demo2();

    public static Demo2 getInstance(){
        return instance;
    }
}

懒汉式 [线程安全]
这种方式会引起性能问题,因为使用了synchorized进行了加锁操

/**
 * 懒汉式单列
 * 通常情况下懒汉式单列是不安全的,但如果使用以下两种方式对构造方法进行处理.那么就会变成线程安全.
 * 这种方式虽然保证了线程安全.但带来的了些问题
 * 当同一时刻有多个线程访问该方法时,由于方法使用了synchronized,导致需要排队进入.从而引起速度问题
 */
public class Demo3 {
    private Demo3(){
    }
    private static Demo3 instance = null;
    public static Demo3 getInstance(){
        synchronized (Demo3.class){
            if (instance == null){
                instance = new Demo3();
            }
        }
        return instance;
    }
    public static synchronized Demo3 getInstance2(){
        if (instance == null){
            instance = new Demo3();
        }
        return instance;
    }
}

饿汉式 [ 通过静态代码块加载 ]

/**
 * 饿汉式单列
 */
public class Demo5 {

    private Demo5(){
    }

    // 这个一定要放在静态代码块前面
    private static Demo5 instance = null;

    static {
        instance = new Demo5();
    }

    public static Demo5 getInstance(){
        return instance;
    }

    public static void main(String[] args) {
        System.out.println(Demo5.getInstance());
    }
}

懒汉式单列 --> 双重同步锁单列模式 [线程安全]

/**
 * 懒汉式单列 --> 双重同步锁单列模式
 *
 * 系统在创建一个对象时是通过以下三步进行操作的
 *
 * 1 : 在内存中分配一个内存空间
 * 2 : 初始化对象
 * 3 : 把第二步中初始化的对象指向第一步分配好的内存地址
 *
 * JVM和CPU优化,发生了指令重排.导致系统并没有按上面的三步走顺序执行,而是变成了1->3->2
 * 所以当我们在执行new操作的时候,有可能是执行了第三步操作.把未被初始化的对象指向了分配的内存,
 * 但实际此时还是个有地址没实际对象的的空壳.所以下一个线程如果正好执行到进入方法判空时发现不为空(实际是有名无分,空壳子),就直接返回了,那么就出现返回了一个空壳子
 *
 * 解决这个问题我们可进行限制指令重排.使用的方式也很简单只要把instance加上关键字 volatile 就可以限制指令重排了
 *
 */
public class Demo4 {

    private Demo4(){

    }

//    private static Demo4 instance = null;
    // 通过volatile进行指令重排禁止
    private static volatile Demo4 instance = null;

    public static Demo4 getInstance2(){
        if (instance == null){
            synchronized(Demo4.class){   // 同步锁
                if (instance == null){
                    instance = new Demo4();
                }
            }
        }
        return instance;
    }
}

枚举方式单列

/**
 * 枚举模式 - 单列 - 最安全:
 * 推荐使用
 */
public class Demo6 {


    private Demo6(){

    }

    public static Demo6 getInstance(){
        return Singleton.INSTANCE.getInstance();
    }

    private enum Singleton{
        INSTANCE;
        private Demo6 singleton;
        // JVM保证这个方法绝对只调用一次
        Singleton(){
            singleton = new Demo6();
        }

        public Demo6 getInstance(){
            return singleton;
        }
    }
}