[01][01][04] 单例模式详解

10/18 12:57
阅读数 15

1. 定义

指确保一个类在任何情况下都绝对只有一个实例,并提供一个全局访问点

2. 适用场景

  • 确保任何情况下都绝对只有一个实例
  • ServletContext,ServletConfig,ApplicationContext,DBPool

3. 分类

  • 饿汉式单例
  • 懒汉式单例
  • 注册式单例
  • ThreadLocal 单例

4. 饿汉式单例

饿汉式单例是在类加载的时候就立即初始化,并且创建单例对象.绝对线程安全,在线程还没出现以前就是实例化了,不可能存在访问安全问题

4.1 优/缺点

  • 优点:没有加任何的锁,执行效率比较高,在用户体验上来说,比懒汉式更好
  • 缺点:类加载的时候就初始化,不管用与不用都占着空间,浪费了内存,有可能占着茅坑不拉屎

4.2 饿汉式单例分类

  • 直接通过 new 创建实例
  • 通过 static 模块创建实例

4.2.1 直接通过 new 创建实例

public class HungrySingleton {

    private static final HungrySingleton hungrySingleton = new HungrySingleton();

    private HungrySingleton() {}

    public static HungrySingleton getInstance() {
        return hungrySingleton;
    }
}

4.2.2 通过 static 模块创建实例

public class HungryStaticSingleton {

    private static final HungryStaticSingleton hungrySingleton;

    private HungryStaticSingleton() {}

    static {
        hungrySingleton = new HungryStaticSingleton();
    }

    public static HungryStaticSingleton getInstance() {
        return hungrySingleton;
    }
}

5. 懒汉式单例

当类被外部调用时才创建实例

懒汉式单例分为以下几种:

  • 简单懒汉式单例
  • 双重检查懒汉式单例
  • 静态内部类懒汉式单例

5.1 简单懒汉式单例

  • 在并发场景下存在线程安全问题,可以创建出多个对象
public class LazySimpleSingleton {

    private static LazySimpleSingleton lazySimpleSingleton = null;

    private LazySimpleSingleton(){}

    public static LazySimpleSingleton getInstance() {
        if (null == lazySimpleSingleton) {
            lazySimpleSingleton = new LazySimpleSingleton();
        }
        return lazySimpleSingleton;
    }
}

5.1.1 多线程调试

在 IDEA 中用线程模式调试,手动控制线程的执行顺序来跟踪内存的变化状态,给 LazySimpleSingleton 加上断点,选择 Thread 模式

debug 启动测试类LazySimpleSingletonTest,线程 0 和 1 进入断点,在 debug 中将线程控制下拉框中切换至线程 0,执行下一行代码后停住

切换至线程 1 执行下一行代码后停住,LazySimpleSingleton类被实例化了两次,这样就破坏了单例模式

输出结果,LazySimpleSingleton 实例化两个对象

多线程类

public class ExecutorThread implements Runnable {
    @Override
    public void run() {
        LazySimpleSingleton lazySimpleSingleton = LazySimpleSingleton.getInstance();
        System.out.println(Thread.currentThread().getName() + ":" + lazySimpleSingleton);
    }
}

多线程测试类

public class LazySimpleSingletonTest {

    public static void main(String[] args) {
        Thread thread1 = new Thread(new ExecutorThread());

        Thread thread2 = new Thread(new ExecutorThread());

        thread1.start();
        thread2.start();

        System.out.println("执行结束");
    }
}

5.2 双重检查懒汉式单例

  • 通过 synchronized 和双重检查,解决简单懒汉式单例存在的线程安全问题
public class LazyDoubleCheckSingleton {

    private static LazyDoubleCheckSingleton lazyDoubleCheckSingleton = null;

    private LazyDoubleCheckSingleton(){}

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

5.2.1 多线程调试

在 IDEA 中用线程模式调试,手动控制线程的执行顺序来跟踪内存的变化状态,给 LazyDoubleCheckSingleton 加上断点,选择 Thread 模式

debug 启动测试类LazyDoubleCheckSingletonTest,线程 0 和 1 进入断点,此时线程 0 和 1 都是 RUNNING

在 debug 中将线程控制下拉框中切换至线程 0,执行下一行代码后停住,此时线程 0 和 1 都是 RUNNING

线程再切换至线程 1 执行下一行代码,此时线程 0 是 RUNNING,线程 1 是 MONITOR,线程 0 拿到锁的情况下,线程 1 无法进入创建实例代码区域

直到线程 0 执行完释放锁线程 1 才能执行代码,此时线程 0 和 1 都是 RUNNING,lazyDoubleCheckSingleton 对象已经创建,if(null==lazyDoubleCheckSingleton)因条件不成立而不进行实例创建,这样线程就是安全的

执行结果,LazyDoubleCheckSingleton 类只被实例化了一次

5.3 静态内部类懒汉式单例

  • 全程没有用到 synchronized
  • 巧妙利用了内部类的特性
  • JVM 底层执行逻辑,完美的避免了线程安全问题
  • 存在被反射***的风险,通过if(null!=LazyHolder.LAZY)解决反射问题
/**
 * 静态内部类懒汉式单例
 */
public class LazyInnerClassSingleton {

    private LazyInnerClassSingleton(){}

    // LazyHolder 里面的逻辑需要等到外部方法调用时才执行
    // 全程没有用到 synchronized
    // 巧妙利用了内部类的特性
    // JVM 底层执行逻辑,完美的避免了线程安全问题
    public static LazyInnerClassSingleton getInstance() {
        return LazyHolder.LAZY;
    }

    private static class LazyHolder {
        private static final LazyInnerClassSingleton LAZY = new LazyInnerClassSingleton();
    }
}

5.4 反射破坏单例

5.4.1 反射如何破坏单例

之前的饿汉和懒汉单例模式的构造方法除了加上 private,如果我们使用反射来调用其构造方法,然后再调用 getInstance()方法,应该就会两个不同的实例

public class LazyInnerClassSingletonTest {

    public static void main(String[] args) throws NoSuchMethodException {
        try {
            Class<?> clazz = LazyInnerClassSingleton.class;

            Constructor constructor = clazz.getDeclaredConstructor(null);
            constructor.setAccessible(true);

            Object object1 = constructor.newInstance();

            Object object2 = LazyInnerClassSingleton.getInstance();

            System.out.println(object1 == object2);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

运行结果为 false,object1 是通过反射创建的,object2 是通常正常创建的,这是两个指向不同内存地址的对象,破坏了单例

5.4.2 解决反射破坏单例

在私有构造方法中增加判断能防止反射破坏单例

private LazyInnerClassSingleton(){
    /**
     * 在私有构造方法中增加判断能防止反射破坏单例
     */
    if (null != LazyHolder.LAZY) {
        throw new RuntimeException("禁止反射创建实例");
    }
}
/**
 * 静态内部类懒汉式单例
 */
public class LazyInnerClassSingleton {

    private LazyInnerClassSingleton(){
        /**
         * 在私有构造方法中增加判断能防止反射破坏单例
         */
        if (null != LazyHolder.LAZY) {
            throw new RuntimeException("禁止反射创建实例");
        }
    }

    // LazyHolder 里面的逻辑需要等到外部方法调用时才执行
    // 全程没有用到 synchronized
    // 巧妙利用了内部类的特性
    // JVM 底层执行逻辑,完美的避免了线程安全问题
    public static LazyInnerClassSingleton getInstance() {
        return LazyHolder.LAZY;
    }

    private static class LazyHolder {
        private static final LazyInnerClassSingleton LAZY = new LazyInnerClassSingleton();
    }
}

运行结果

5.5 序列化破坏单例

通过序列化将对象输出到文件,再通过反序列化将文件加载到内存,这样单例实例将在内存中存在两个对象,从而破坏单例模式

5.5.1 序列化如何破坏单例

饿汉模式的单例

public class SerializableSingleton implements Serializable {
    private static final SerializableSingleton serializableSingleton = new SerializableSingleton();

    private SerializableSingleton() {}

    public static SerializableSingleton getInstance() {
        return serializableSingleton;
    }
}

序列化测试类

public class SerializableSingletonTest {
    public static void main(String[] args) {
        SerializableSingleton s1 = null;
        SerializableSingleton s2 = SerializableSingleton.getInstance();

        FileOutputStream fileOutputStream = null;
        FileInputStream fileInputStream = null;
        ObjectOutputStream objectOutputStream = null;
        ObjectInputStream objectInputStream = null;

        try {
            fileOutputStream = new FileOutputStream("./singleton/SerializableSingleton.obj");
            objectOutputStream = new ObjectOutputStream(fileOutputStream);
            objectOutputStream.writeObject(s2);
            objectOutputStream.flush();
            objectOutputStream.close();

            fileInputStream = new FileInputStream("./singleton/SerializableSingleton.obj");
            objectInputStream = new ObjectInputStream(fileInputStream);
            s1 = (SerializableSingleton) objectInputStream.readObject();
            objectInputStream.close();

            System.out.println(s1 == s2);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            IOUtils.closeQuietly(objectInputStream);
            IOUtils.closeQuietly(objectOutputStream);
            IOUtils.closeQuietly(fileInputStream);
            IOUtils.closeQuietly(fileOutputStream);
        }
    }
}

输出结果为两个对象 s1,s2 不相等,SerializableSingleton 对象实例化了两个对象,分别指向不同的内存地址

5.5.2 解决序列化破坏单例模式

在单例类中重写readResolve()方法

public class SerializableSingleton implements Serializable {
    private static final SerializableSingleton serializableSingleton = new SerializableSingleton();

    private SerializableSingleton() {}

    public static SerializableSingleton getInstance() {
        return serializableSingleton;
    }

    // 重写 readResolve 方法只不过是覆盖了反序列化出来的对象
    // 还是创建了两次,只不过是发生在 JVM 层面,相对来说说比较安全
    // 之前反序列化出来的对象会被 GC 回收
    private Object readResolve() {
        return serializableSingleton;
    }
}

5.5.3 源码解读

在序列化测试类的代码中s1=(SerializableSingleton)objectInputStream.readObject(),查看readObject()方法源码

public final Object readObject() throws IOException, ClassNotFoundException
{
    if (enableOverride) {
        return readObjectOverride();
    }

    // if nested read, passHandle contains handle of enclosing object
    int outerHandle = passHandle;
    try {
        Object obj = readObject0(false);
        handles.markDependency(outerHandle, passHandle);
        ClassNotFoundException ex = handles.lookupException(passHandle);
        if (ex != null) {
            throw ex;
        }
        if (depth == 0) {
            vlist.doCallbacks();
        }
        return obj;
    } finally {
        passHandle = outerHandle;
        if (closed && depth == 0) {
            clear();
        }
    }
}

readObject()源码中可以查看到readObject0()方法,在TC_OBJECT中调用readOrdinaryObject()

private Object readObject0(boolean unshared) throws IOException {
    ...
    case TC_OBJECT:
        return checkResolve(readOrdinaryObject(unshared));
    ...
}

readOrdinaryObject()方法中desc.isInstantiable()判断是否存在构造方法

private Object readOrdinaryObject(boolean unshared) throws IOException
{
    ...
    Object obj;
    try {
        obj = desc.isInstantiable() ? desc.newInstance() : null;
    } catch (Exception ex) {

    ...

    if (obj != null && handles.lookupException(passHandle) == null && desc.hasReadResolveMethod())
    {
        Object rep = desc.invokeReadResolve(obj);
        if (unshared && rep.getClass().isArray()) {
            rep = cloneArray(rep);
        }
        if (rep != obj) {
            // Filter the replacement object
            if (rep != null) {
                if (rep.getClass().isArray()) {
                    filterCheck(rep.getClass(), Array.getLength(rep));
                } else {
                    filterCheck(rep.getClass(), -1);
                }
            }
            handles.setObject(passHandle, obj = rep);
        }
    }
}

调用了 ObjectStreamClass 的 isInstantiable()方法,而 isInstantiable()里面的代码,判断一下构造方法是否为空,构造方法不为空就返回 true,意味着只要有无参构造方法就会实例化

boolean isInstantiable() {
    requireInitialized();
    return (cons != null);
}

判断无参构造方法是否存在之后,又调用了 hasReadResolveMethod()方法

boolean hasReadResolveMethod() {
    requireInitialized();
    return (readResolveMethod != null);
}

就是判断 readResolveMethod 是否为空,不为空就返回 true,通过全局查找找到了 ObjectStreamClass 中对 readResolveMethod 赋值代码在私有方法

readResolveMethod = getInheritableMethod(cl, "readResolve", null, Object.class);

在代码可以看到这样一行代码if(obj!=null&&handles.lookupException(passHandle)==null&&desc.hasReadResolveMethod()),如果这个判断返回为 true,将能执行desc.invokeReadResolve(obj)调用序列化对象中的 readResolve 方法

  • obj 已经实例化不为空
  • handles.lookupException(passHandle)返回结果为空,没有异常
  • desc.hasReadResolveMethod()返回 true

    private Object readOrdinaryObject(boolean unshared) throws IOException
    {
    ...
    if (obj != null && handles.lookupException(passHandle) == null && desc.hasReadResolveMethod())
    {
    Object rep = desc.invokeReadResolve(obj);
    if (unshared && rep.getClass().isArray()) {
    rep = cloneArray(rep);
    }
    if (rep != obj) {
    // Filter the replacement object
    if (rep != null) {
    if (rep.getClass().isArray()) {
    filterCheck(rep.getClass(), Array.getLength(rep));
    } else {
    filterCheck(rep.getClass(), -1);
    }
    }
    handles.setObject(passHandle, obj = rep);
    }
    }
    }



















invokeReadResolve()方法中用反射调用了readResolveMethod方法

Object invokeReadResolve(Object obj) throws IOException, UnsupportedOperationException
{
    requireInitialized();
    if (readResolveMethod != null) {
        try {
            return readResolveMethod.invoke(obj, (Object[]) null);
        } catch (InvocationTargetException ex) {
            Throwable th = ex.getTargetException();
            if (th instanceof ObjectStreamException) {
                throw (ObjectStreamException) th;
            } else {
                throwMiscException(th);
                throw new InternalError(th);  // never reached
            }
        } catch (IllegalAccessException ex) {
            // should not occur, as access checks have been suppressed
            throw new InternalError(ex);
        }
    } else {
        throw new UnsupportedOperationException();
    }
}

通过 JDK 源码分析我们可以看出,虽然增加readResolve()方法返回实例,解决了单例被破坏的问题.但是我们通过分析源码以及调试,我们可以看到实际上实例化了两次,只不过新创建的对象没有被返回而已.那如果创建对象的动作发生频率增大,就意味着内存分配开销也就随之增大,难道真的就没办法从根本上解决问题吗?下面我们来注册式单例也许能帮助到你

6. 注册式单例

注册式单例又称为登记式单例,就是将每一个实例都登记到某一个地方,使用唯一的标识获取实例

注册式单例有两种写法:

  • 容器缓存
  • 枚举登记

6.1 枚举登记式单例

枚举单例类

public enum EnumSingleton {
    INSTANCE;

    private Object data;

    public void setData(Object data) {
        this.data = data;
    }

    public Object getData() {
        return data;
    }

    public static EnumSingleton getInstance() {
        return INSTANCE;
    }
}

反序列化测试类

public class EnumSingletonTest {
    public static void main(String[] args) {
        EnumSingleton s1 = null;
        EnumSingleton s2 = EnumSingleton.getInstance();

        FileOutputStream fileOutputStream = null;
        FileInputStream fileInputStream = null;
        ObjectOutputStream objectOutputStream = null;
        ObjectInputStream objectInputStream = null;

        try {
            fileOutputStream = new FileOutputStream("./singleton/EnumSingleton.obj");
            objectOutputStream = new ObjectOutputStream(fileOutputStream);
            objectOutputStream.writeObject(s2);
            objectOutputStream.flush();
            objectOutputStream.close();

            fileInputStream = new FileInputStream("./singleton/EnumSingleton.obj");
            objectInputStream = new ObjectInputStream(fileInputStream);
            s1 = (EnumSingleton) objectInputStream.readObject();
            objectInputStream.close();

            System.out.println(s1 == s2);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            IOUtils.closeQuietly(objectInputStream);
            IOUtils.closeQuietly(objectOutputStream);
            IOUtils.closeQuietly(fileInputStream);
            IOUtils.closeQuietly(fileOutputStream);
        }
    }
}

运行结果,两个对象 s1,s2 指向同一块内存地址,是同一个对象

这种方式没有做任何处理却能完美的解决序列化破坏单例,那么枚举式单例如此神奇,通过反编译工具解开神秘面纱

在 IDEA 中找到 EnumSingleton 对应的 class 文件 EnumSingleton.class,复制所在路径

然后切回到命令行,切换到工程所在的 Class 目录,输入命令 jad 后面输入复制好的路径,我们会在 Class 目录下会多一个 EnumSingleton.jad 文件.打开 EnumSingleton.jad 文件我们惊奇又巧妙地发现有如下代码:

static {
    INSTANCE = new EnumSingleton("INSTANCE", 0);
    $VALUES = (new EnumSingleton[] {
        INSTANCE
    });
}

原来枚举式单例在静态代码块中就给 INSTANCE 进行了赋值,是饿汉式单例的实现.我们还可以试想,序列化我们能否破坏枚举式单例呢?我们不妨再来看一下 JDK 源码,还是回到 ObjectInputStream 的 readObject0()方法

private Object readObject0(boolean unshared) throws IOException {
    ...

    case TC_ENUM:
        return checkResolve(readEnum(unshared));
    ...
}

在 readObject0()中调用了 readEnum()方法,来看 readEnum()中代码实现

private Enum<?> readEnum(boolean unshared) throws IOException {
    if (bin.readByte() != TC_ENUM) {
        throw new InternalError();
    }

    ObjectStreamClass desc = readClassDesc(false);
    if (!desc.isEnum()) {
        throw new InvalidClassException("non-enum class: " + desc);
    }

    int enumHandle = handles.assign(unshared ? unsharedMarker : null);
    ClassNotFoundException resolveEx = desc.getResolveException();
    if (resolveEx != null) {
        handles.markException(enumHandle, resolveEx);
    }

    String name = readString(false);
    Enum<?> result = null;
    Class<?> cl = desc.forClass();
    if (cl != null) {
        try {
            @SuppressWarnings("unchecked")
            Enum<?> en = Enum.valueOf((Class)cl, name);
            result = en;
        } catch (IllegalArgumentException ex) {
            throw (IOException) new InvalidObjectException(
                "enum constant " + name + " does not exist in " +
                cl).initCause(ex);
        }
        if (!unshared) {
            handles.setObject(enumHandle, result);
        }
    }

    handles.finish(enumHandle);
    passHandle = enumHandle;
    return result;
}

发现枚举类型其实通过类名和 Class 对象类找到一个唯一的枚举对象,因此枚举对象不可能被类加载器加载多次

那么反射是否能破坏枚举式单例呢?来看一段测试代码:

public static void main(String[] args) {
    try {
        Class clazz = EnumSingleton.class;
        Constructor c = clazz.getDeclaredConstructor();
        c.newInstance();
    }catch (Exception e){
        e.printStackTrace();
    }
}

运行结果

报的是 java.lang.NoSuchMethodException 异常,意思是没找到无参的构造方法.这时候,我们打开 java.lang.Enum 的源码代码,查看它的构造方法,只有一个 protected 的构造方法,代码如下:

protected Enum(String name, int ordinal) {
    this.name = name;
    this.ordinal = ordinal;
}

那我们再来做一个这样的测试:

public static void main(String[] args) {
    try {
        Class clazz = EnumSingleton.class;
        Constructor c = clazz.getDeclaredConstructor(String.class,int.class);
        c.setAccessible(true);
        EnumSingleton enumSingleton = (EnumSingleton)c.newInstance("Tom",666);
    }catch (Exception e){
        e.printStackTrace();
    }
}

运行结果

这时错误已经非常明显了,告诉我们 Cannotreflectivelycreateenumobjects,不能用反射来创建枚举类型.还是习惯性地想来看看 JDK 源码,进入 Constructor 的 newInstance()方法:

public T newInstance(Object ... initargs)
    throws InstantiationException, IllegalAccessException,
        IllegalArgumentException, InvocationTargetException
{
    if (!override) {
        if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
            Class<?> caller = Reflection.getCallerClass(); checkAccess(caller, clazz, null, modifiers);
        }
    }

    if ((clazz.getModifiers() & Modifier.ENUM) != 0) {
        throw new IllegalArgumentException("Cannot reflectively create enum objects");
    }

    ConstructorAccessor ca = constructorAccessor;

    if (ca == null) {
        ca = acquireConstructorAccessor();
    }

    @SuppressWarnings("unchecked")
    T inst = (T) ca.newInstance(initargs);

    return inst;
}

在 newInstance()方法中做了强制性的判断,如果修饰符是 Modifier.ENUM 枚举类型,直接抛出异常.到这为止,我们是不是已经非常清晰明了呢?枚举式单例也是《EffectiveJava》书中推荐的一种单例实现写法.在 JDK 枚举的语法特殊性,以及反射也为枚举保驾护航,让枚举式单例成为一种比较优雅的实现

6.2 容器缓存单例

容器式写法适用于创建实例非常多的情况,便于管理,是非线程安全的

public class ContainerSingleton {

    private ContainerSingleton(){}

    private static Map<String,Object> ioc = new ConcurrentHashMap<String,Object>();

    public static Object getBean(String className){
        synchronized (ioc) {
            if (!ioc.containsKey(className)) {
                Object obj = null;

                try {
                    obj = Class.forName(className).newInstance();
                    ioc.put(className, obj);
                } catch (Exception e) {
                    e.printStackTrace();
                }

                return obj;
            } else {
                return ioc.get(className);
            }
        }
    }
}

Spring 中的容器式单例的实现代码

public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory implements AutowireCapableBeanFactory {
    /** Cache of unfinished FactoryBean instances: FactoryBean name --> BeanWrapper */
    private final Map<String, BeanWrapper> factoryBeanInstanceCache = new ConcurrentHashMap<>(16);
    ...
}

7. ThreadLocal 单例

ThreadLocal 不能保证其创建的对象是全局唯一,但是能保证在单个线程中是唯一的,天生的线程安全.下面我们来看代码:

public class ThreadLocalSingleton {

    private static final ThreadLocal<ThreadLocalSingleton> threadLocalInstance =
            new ThreadLocal<ThreadLocalSingleton>() {
                @Override
                protected ThreadLocalSingleton initialValue() {
                    return new ThreadLocalSingleton();
                }
            };

    private ThreadLocalSingleton() {
    }

    public static ThreadLocalSingleton getInstance() {
        return threadLocalInstance.get();
    }
}

多线程执行类

public class ThreadLocalExectorThread implements Runnable {

    @Override
    public void run() {
        ThreadLocalSingleton threadLocalSingleton = ThreadLocalSingleton.getInstance();

        System.out.println(Thread.currentThread().getName() + ":" + threadLocalSingleton);
    }
}

测试类

public class ThreadLocalSingletonTest {

    public static void main(String[] args) {
        System.out.println(ThreadLocalSingleton.getInstance());
        System.out.println(ThreadLocalSingleton.getInstance());
        System.out.println(ThreadLocalSingleton.getInstance());
        System.out.println(ThreadLocalSingleton.getInstance());
        System.out.println(ThreadLocalSingleton.getInstance());
        Thread t1 = new Thread(new ThreadLocalExectorThread());
        Thread t2 = new Thread(new ThreadLocalExectorThread());
        t1.start();
        t2.start();
    }
}

输出结果

我们发现,在主线程 main 中无论调用多少次,获取到的实例都是同一个,都在两个子线程中分别获取到了不同的实例.那么 ThreadLocal 是如果实现这样的效果的呢?我们知道上面的单例模式为了达到线程安全的目的,给方法上锁,以时间换空间.ThreadLocal 将所有的对象全部放在 ThreadLocalMap 中,为每个线程都提供一个对象,实际上是以空间换时间来实现线程间隔离的

展开阅读全文
打赏
0
0 收藏
分享
加载中
更多评论
打赏
0 评论
0 收藏
0
分享
返回顶部
顶部