懒汉单例模式下的线程安全问题

• 单例解决保证一个类对外只产生一个对象
• 单例的实现方式很多
• 饿汉单例模式。饿汉单例模式是在获取对象前，对象已经准备好了，所以饿汉单例模式天生就是线程安全的！
• 懒汉单例模式。一开始不去创建对象，等到要用这个实例对象的时候，才判断它存不存在真正的实例对象，如果存在我们就返回，不存在才去创建一个对象，那么这样，就可能会有问题，在多个线程都判断它都没有实例对象的时候，可能多个线程会多次创建这个实例对象！此时，会出现线程安全问题！

package com.gch.d17_thread_safe_single_instance;

/**
   懒汉单例模式
 */
public class SingleInstance {
    /**
       1.私有化构造器
     */
    private SingleInstance(){

    }

    /**
       2.定义一个静态的成员变量存储一个对象
       静态成员变量在内存中只加载一次,在内存中只存储一份
       注意:最好私有化,这样避免给别人挖坑
     */
    private static SingleInstance instance; // null

    /**
       3.提供一个方法,对外返回单例对象
     */
    public static SingleInstance getInstance() {
        if(instance == null){
//            try {
//                Thread.sleep(500);
//            } catch (InterruptedException e) {
//                throw new RuntimeException(e);
//            }
            // 1.第一次拿对象,此时需要创建对象
            instance = new SingleInstance();
        }
        return instance;
    }

}

package com.gch.d17_thread_safe_single_instance;

/**
   懒汉单例模式下线程安全问题
 */
public class Test {
    public static void main(String[] args) {
//        SingleInstance s1 = SingleInstance.getInstance();
//        SingleInstance s2 = SingleInstance.getInstance();
//        System.out.println(s1); // om.gch.d17_thread_safe_single_instance.SingleInstance@4554617c
//        System.out.println(s2); // com.gch.d17_thread_safe_single_instance.SingleInstance@4554617c
//        System.out.println(s1 == s2); // true

        new Thread(new Runnable() {
            @Override
            public void run() {
                SingleInstance instance = SingleInstance.getInstance();
                System.out.println(instance);
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
               SingleInstance instance = SingleInstance.getInstance();
                System.out.println(instance);
            }
        }).start();
    }
}

• @后面打印的是对象的哈希值，hascode不一样，足以证明这是两个引用，两个引用指向的肯定是两个实例对象。
• 为什么在多线程下会出现创建了2个不同的对象，看下图：
• 

 如何解决懒汉单例模式下的线程安全问题：

• 把返回单例对象的方法给改成同步方法（同步方法下的懒汉式单例 => 常规）或者同步代码块（这就需要DCL双重检测）即可，让每次只有一个线程进来返回单例对象。

package com.gch.d17_thread_safe_single_instance;

/**
   懒汉单例模式
 */
public class SingleInstance {
    /**
       1.私有化构造器
     */
    private SingleInstance(){

    }

    /**
       2.定义一个静态的成员变量存储一个对象
       静态成员变量在内存中只加载一次,在内存中只存储一份
       注意:最好私有化,这样避免给别人挖坑
     */
    private static SingleInstance instance; // null

    /**
       3.提供一个方法,对外返回单例对象
       加synchronized改为同步方法
     */
    public static synchronized SingleInstance getInstance() {
        if(instance == null){
//            try {
//                Thread.sleep(500);
//            } catch (InterruptedException e) {
//                throw new RuntimeException(e);
//            }
            // 1.第一次拿对象,此时需要创建对象
            instance = new SingleInstance();
        }
        return instance;
    }
}

package com.gch.d17_thread_safe_single_instance;

/**
   懒汉单例模式下线程安全问题
 */
public class Test {
    public static void main(String[] args) {
//        SingleInstance s1 = SingleInstance.getInstance();
//        SingleInstance s2 = SingleInstance.getInstance();
//        System.out.println(s1); // om.gch.d17_thread_safe_single_instance.SingleInstance@4554617c
//        System.out.println(s2); // com.gch.d17_thread_safe_single_instance.SingleInstance@4554617c
//        System.out.println(s1 == s2); // true

        new Thread(new Runnable() {
            @Override
            public void run() {
                SingleInstance instance = SingleInstance.getInstance();
                System.out.println(instance);
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
               SingleInstance instance = SingleInstance.getInstance();
                System.out.println(instance);
            }
        }).start();
    }
}

• 这样就解决了懒汉单例模式下的线程安全问题，不论创建多少个线程去创建实例对象，此时创建的都是同一个实例对象，符合单例模式对外只创建一个对象的原则。