单例模式在多线程下的情况

单例模式在多线程下的情况

介绍一下单例模式

---

概念：

单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。其实就是指保证一个类只能有一个实例，并且要提供一个访问它的全局访问点，它的主要目的就是为了防止一个全局使用的类被频繁的创建和销毁，这样也可以节省很多的系统资源。

特点：

1. 单例类只能有一个实例
2. 单例类必须自己创建自己的唯一实例
3. 单例类必须给所有其他对象提供这一实例

优点：

1. 在内存中只存在一个实例，这样减少了内存的开销，尤其是类被频繁的创建和销毁会导致缓存占用内存过多，影响效率。
2. 避免对资源的多重占用（比如写文件的操作）。

缺点：

1. 没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。

使用场景：

1. 要求生产唯一序列号。
2. WEB 中的计数器，不用每次刷新都在数据库里加一次，用单例先缓存起来
3. 创建的一个对象需要消耗的资源过多，比如 I/O 与数据库的连接等。

单例模式的实现方式

---

1. 饿汉式：

实现代码：

package com.czu.single;

/**
 * 饿汉式单例
 * @author 87682
 */
public class Hungry {

    /**
     * 可能会浪费空间
     */
    private byte[] data1 = new byte[1024*1024];
    private byte[] data2 = new byte[1024*1024];
    private byte[] data3 = new byte[1024*1024];
    private byte[] data4 = new byte[1024*1024];


    private Hungry(){

    }

    private final static Hungry HUNGRY = new Hungry();

    public static Hungry getInstance(){
        return HUNGRY;
    }
}

这种方法的弊端在注释里面也写了，就是会浪费很多内存空间，虽然也能实现线程安全，不必加锁，执行效率高，但是在类被加载的时候会不断的初始化，instance 在类装载时就实例化，虽然导致类装载的原因有很多种，在单例模式中大多数都是调用 getInstance 方法， 但是也不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化 instance 显然没有达到 lazy loading 的效果。

2. 懒汉式：

实现代码：

package com.czu.single;

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

/**
 * 懒汉式单例模式
 *
 * @author 87682
 */
public class LazyMan {

    private static boolean qinjiang = false;

    private LazyMan() {
        synchronized (LazyMan.class) {
            if (qinjiang == false) {
                qinjiang = true;
            } else {
                throw new RuntimeException("不要试图使用反射破坏异常");
            }
        }
    }

    private volatile static LazyMan lazyMan;

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

        return lazyMan;
    }

//    /**
//     * 多线程并发
//     */
//    public static void main(String[] args) {
//        for (int i = 0; i < 10; i++) {
//            new Thread(()->{
//                LazyMan.getInstance();
//            }).start();
//        }
//    }

    /**
     * 反射
     */
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        //LazyMan instance = LazyMan.getInstance();
        Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);
        LazyMan instance = declaredConstructor.newInstance();
        LazyMan instance2 = declaredConstructor.newInstance();
        System.out.println(instance);
        System.out.println(instance2);
    }

}

代码中也提到了，如果有人利用反射类加载的方式，或者说反编译的方式去恶意加载类，会导致很多不安全的问题，在普通的懒汉式单例模式中，线程是不安全的，所以我们需要使用双重检测锁模式的懒汉式单例来解决问题，由于实例不能保持原子性，所以会导致指令重排的现象，于是我们会添加volatile关键字来保证原子性，这样既保证原子性又不会造成线程不安全的现象。

3. 静态内部类方式实现单例模式：

实现代码：

package com.czu.single;

/**
 * 静态内部类
 * @author 87682
 */
public class Holder {
    private Holder(){

    }

    public static Holder getInstance(){
        return InnerClass.HOLDER;
    }

    public static class InnerClass{
        private static final Holder HOLDER = new Holder();
    }
}

这种方式能达到双检锁方式一样的功效，但实现更简单。对静态域使用延迟初始化，应使用这种方式而不是双检锁方式。这种方式只适用于静态域的情况，双检锁方式可在实例域需要延迟初始化时使用。这种方式同样利用了 classloader 机制来保证初始化 instance 时只有一个线程。它跟懒汉式不同的是：懒汉式只要单例类被装载了，那么 instance 就会被实例化（没有达到 lazy loading 效果），而这种方式是 单例类 类被装载了，instance 不一定被初始化。因为 Holder类没有被主动使用，只有通过显式调用 getInstance 方法时，才会显式装载 Holder类，从而实例化 instance。想象一下，如果实例化 instance 很消耗资源，所以想让它延迟加载，另外一方面，又不希望在 单例类类加载时就实例化，因为不能确保 单例类类还可能在其他的地方被主动使用从而被加载，那么这个时候实例化 instance 显然是不合适的。这个时候，这种方式相比懒汉式就显得很合理。

4. 枚举式单例模式：

package com.czu.single;

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

/**
 * enum 是一个什么？ 本身也是一个Class类
 * @author 87682
 */
public enum  EnumSingle {
    /**
     *
     */
    INSTANCE;
    public EnumSingle getInstance(){
        return INSTANCE;
    }
}

class Test{
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        EnumSingle instance1 = EnumSingle.INSTANCE;
        Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(String.class,int.class);
        declaredConstructor.setAccessible(true);
        EnumSingle instance2 = declaredConstructor.newInstance();

        //java.lang.NoSuchMethodException: com.czu.single.EnumSingle.<init>()
        System.out.println(instance1);
        System.out.println(instance2);

    }
}

这种实现方式还没有被广泛采用，但这是实现单例模式的最佳方法。它更简洁，自动支持序列化机制，绝对防止多次实例化。这种方式是 Effective Java 作者 Josh Bloch 提倡的方式，它不仅能避免多线程同步问题，而且还自动支持序列化机制，防止反序列化重新创建新的对象，绝对防止多次实例化。不过，由于 JDK1.5 之后才加入 enum 特性，用这种方式写不免让人感觉生疏，在实际工作中，也很少用。不能通过 reflection attack 来调用私有构造方法（用来防止别人用反编译的方式恶意破坏），同时也能保证线程安全。