单例模式---懒汉式的优化

单例模式中最重要的思想是：构造器私有，因此能保证我们的内存中只有一个对象。

单例模式分为懒汉式和饿汉式

1.饿汉式：顾名思义，很饿，上来就吃。

package cn.com;

//饿汉式单例，在程序运行时，无论是否需要 都会创建对象，因此  可能会浪费空间
public class HungryMan {

    //构造器私有，无法new 这个对象
    private HungryMan() {

    }
    private  static HungryMan HUNGRY = new HungryMan();

    private static HungryMan getInstance() {
        return HUNGRY;
    }

    //测试后 得到的 对象的hashcode 一致，说明是同一个对象
    public static void main(String[] args) {
        HungryMan instance1 = HungryMan.getInstance();
        HungryMan instance2 = HungryMan.getInstance();
        HungryMan instance3 = HungryMan.getInstance();
        // 打印hashcode
        System.out.println(instance1);
        System.out.println(instance1);
        System.out.println(instance1);
    }
}
运行结果： 三个对象的hashcode 值一样，说明是指向了同一个对象
cn.com.Hungry@1b6d3586
cn.com.Hungry@1b6d3586
cn.com.Hungry@1b6d3586

2.懒汉式单例

package cn.com;

public class LazyMan1 {
    //构造器私有
    private LazyMan1() {
        System.out.println(Thread.currentThread().getName() + "  正在运行！");
    }

    //先不创建 ，等使用的时候再去创建
    private static LazyMan1 man;

    public static LazyMan1 getInstance() {
        if (man == null) {
            man = new LazyMan1();
        }
        return man;
    }

    /**
     * 此代码是线程不安全的，只在单线程下可以
     * 例如
     */
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            new Thread(() -> {
                LazyMan1.getInstance();
            }).start();
        }
    }
}
运行结果

Thread-0  正在运行！
Thread-3  正在运行！
Thread-2  正在运行！
Thread-1  正在运行！

单例模式下，存在多个线程，明显不符合单例模式要求。下面对代码进行改进

3.懒汉式单例 改进

注： new LazyMan();不是原子性操作，实际底层有三步，

1.分配内存空间 

2.执行构造方法，初始化对象

 3.把对象指向这个空间 

当A线程执行方法时，可能在执行 1---3---2 ；如果此时B线程进入，由于A线程已经将空对象指向内存空间，因此B将会得到一个null的对象。所以，必须使用volatile  修饰符 避免 被指令重排

package cn.com;

//懒汉式单例
public class LazyMan {

    //构造器私有
    private LazyMan() {
        System.out.println(Thread.currentThread().getName() + "is ok ");
    }

    //volatile 避免被指令重排
    private volatile static LazyMan lanzMan;

    //双重检测锁 模式的懒汉式单例   ----DCL 懒汉式
    public static LazyMan getInstance() {
        if (lanzMan == null) {
            synchronized (LazyMan.class) {
                if (lanzMan == null) {
                    lanzMan = new LazyMan();
                }
            }
        }
        return lanzMan;
    }

    //多线程并发
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            new Thread(() -> {
                LazyMan.getInstance();
            }).start();
        }
    }
}
多次运行结果均为Thread-0is ok ；说明在多线程下是安全的。

4.尽管我们使用了双重检测锁，但是由于反射的存在，上述代码仍然是不安全的。例如，我们通过反射机制来破坏单例模式。

package cn.com;

import java.lang.reflect.Constructor;

//懒汉式单例
public class LazyMan {

    //构造器私有
    private LazyMan() {
        System.out.println(Thread.currentThread().getName() + "is ok ");
    }

    //volatile 避免被指令重排
    private volatile static LazyMan lanzMan;

    //双重检测锁 模式的懒汉式单例   ----DCL 懒汉式
    public static LazyMan getInstance() {
        if (lanzMan == null) {
            synchronized (LazyMan.class) {
                if (lanzMan == null) {
                    lanzMan = new LazyMan();
                    /**
                     *  new LazyMan();不是原子性操作;
                     * 1.分配内存空间
                     * 2.执行构造方法，初始化对象
                     * 3.把对象指向这个空间
                     */
                }
            }
        }
        return lanzMan;
    }

    //由于反射的存在，即使 使用双重检测锁 ，在多线程下也是不安全的
    public static void main(String[] args) throws Exception {
        //实例1
        LazyMan lazyMan1 = LazyMan.getInstance();

        /**
         * 通过反射破坏单例模式
         */
        //获取空参构造器
        Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);// 可以无视私有构造器
        LazyMan lazyMan2 = declaredConstructor.newInstance();
        System.out.println(lazyMan1.hashCode());
        System.out.println(lazyMan2.hashCode());
    }
}
运行结果

460141958
1163157884

由此可见，单例模式下 我们获取的是两个不同的对象。

解决办法：在构造器加synchronized，又双重检测锁升级为三重检测锁

//构造器私有
private LazyMan() {
        synchronized (LazyMan.class) {
            if (lanzMan != null) {
                throw new RuntimeException("不要来搞破坏");
            }
        }
}

再执行代码，结果：

上述解决办法可行吗？再来。。。

我们将获取对象的方式全改为 反射获取

//由于反射的存在，即使 使用双重检测锁 ，在多线程下也是不安全的
public static void main(String[] args) throws Exception {
 
    Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);
    declaredConstructor.setAccessible(true);// 可以无视私有构造器
    LazyMan lazyMan1 = declaredConstructor.newInstance();
    LazyMan lazyMan2 = declaredConstructor.newInstance();
    System.out.println(lazyMan1.hashCode());
    System.out.println(lazyMan2.hashCode());
}

执行结果：  发现 又获取到了不同对象。。。。。

解决办法：通过在构造器增加标志位

package cn.com;

import sun.nio.cs.FastCharsetProvider;

import java.lang.reflect.Constructor;

//懒汉式单例
public class LazyMan {
    private static boolean str = false;

    //构造器私有
    private LazyMan() {
        synchronized (LazyMan.class) {
            if (str == false) {
                str = true;
            } else {
                    throw new RuntimeException("不要来搞破坏");
            }
        }
    }
    private volatile static LazyMan lanzMan;

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

    public static void main(String[] args) throws Exception {
        //获取空参构造器
        Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);// 可以无视私有构造器
        LazyMan lazyMan1 = declaredConstructor.newInstance();
        LazyMan lazyMan2 = declaredConstructor.newInstance();
        System.out.println(lazyMan1.hashCode());
        System.out.println(lazyMan2.hashCode());
    }
}
执行结果，问题已解决。  我想说，，，其实这种方法仍然是不安全的，后面讲如何通过枚举类解决此问题