java-单例模式双重检测和枚举实现

双重检测实现

package com.designmodel.single;

import java.util.concurrent.atomic.AtomicLong;
/**
* @description: 单例模式-双重检测
* @fileName: DoubleLoad.java
* @author: Sure
* @createAt: 2022/3/21 16:46
* @updateBy: Sure
* @remark: 
*/
public class DoubleLoad {
    //饿汉式不支持延迟加载，懒汉式有性能问题，不支持高并发。那我们再来看一种既支持延迟加载、又支持高并发的单例实现方式，也就是双重检测实现方式。
    //
    private AtomicLong id = new AtomicLong(0);
    private static DoubleLoad instance;
    private DoubleLoad() {}
    public static DoubleLoad getInstance() {
        if (instance == null) {
            synchronized(DoubleLoad.class) { // 此处为类级别的锁
                if (instance == null) {
                    instance = new DoubleLoad();
                }
            }
        }
        return instance;
    }
    public long getId() {
        return id.incrementAndGet();
    }
}

枚举实现：

package com.designmodel.single;
/**
* @description:
* @fileName: Resource.java
* @author: Sure
* @createAt: 2022/3/22 15:33
* @updateBy: Sure
* @remark: 
*/
public class Resource {

    /**
     * 枚举类对象本身就是一个单例对象。
     * 没有延时加载的特性。
     * 可以天然的防止反射和反序列化的漏洞，因为枚举是基于JVM底层实现的。
     * 结论：线程安全，调用效率高，但是不是延时加载，天然防止反射和反序列化漏洞。
     */
    private Resource(){}

    /**
     * 枚举类型是线程安全的，并且只会装载一次
     */
    private enum Singletons{
        INSTANCE;

        private final Resource instance;

        Singletons(){
            instance = new Resource();
        }

        private Resource getInstance(){
            return instance;
        }
    }

    public static Resource getInstance(){

        return Singletons.INSTANCE.getInstance();
    }


}