标签：getInstance 实现 汇总 System private static 单例 println out

1. 启动时加载
      1.1 - static new
      1.2 - static class new
2. 延迟加载
      2.1 - synchronized
      2.2 - 双重锁检查 + volatile
      2.3 - Java9中引入AtomicReference
3. 枚举实现

public class SingletonDemo {

    //1. 启动时加载
    //      1.1 - static new
    //      1.2 - static class new
    //2. 延迟加载
    //      2.1 - synchronized
    //      2.2 - 双重锁检查 + volatile
    //      2.3 - Java9中引入AtomicReference
    //3. 枚举实现

    public static void main(String[] args) {
        System.out.println(SingletonV11.getInstance() == SingletonV11.getInstance());
        System.out.println(SingletonV12.getInstance() == SingletonV12.getInstance());
        System.out.println(SingletonSynchronized.getInstance() == SingletonSynchronized.getInstance());
        System.out.println(SingletonDoubleCheckVolatile.getInstance() == SingletonDoubleCheckVolatile.getInstance());
        System.out.println(SingletonAtomicReference.getInstance() == SingletonAtomicReference.getInstance());
        System.out.println(SingletonEnum.getInstance() == SingletonEnum.getInstance());
    }

    //1.1 - 启动时初始化单例
    static class SingletonV11 {
        private static final SingletonV11 singletonV11 = new SingletonV11();

        private SingletonV11() {
            System.out.println("SingletonV11()");
        }

        public static SingletonV11 getInstance() {
            return singletonV11;
        }
    }

    //1.2 - 启动时利用内部静态类初始化单例
    static class SingletonV12 {

        private static class SingletonHolder {
            private static final SingletonV12 singletonV12 = new SingletonV12();
        }

        private SingletonV12() {
            System.out.println("SingletonV12()");
        }

        public static SingletonV12 getInstance() {
            return SingletonHolder.singletonV12;
        }
    }

    //2.1 - synchronized版本，线程排队执行
    static class SingletonSynchronized {

        private static SingletonSynchronized singletonSynchronized = null;

        private SingletonSynchronized() {
            System.out.println("SingletonSynchronized()");
        }

        public synchronized static SingletonSynchronized getInstance() {
            if (singletonSynchronized == null) {
                singletonSynchronized = new SingletonSynchronized();
            }
            return singletonSynchronized;
        }
    }

    //2.2 - 双重检查 + volatile
    static class SingletonDoubleCheckVolatile {

        private volatile static SingletonDoubleCheckVolatile singletonDoubleCheckVolatile = null;

        private SingletonDoubleCheckVolatile() {
            System.out.println("耗时长");
            System.out.println("SingletonDoubleCheckVolatile()");
        }

        public static SingletonDoubleCheckVolatile getInstance() {
            if (singletonDoubleCheckVolatile == null) {
                synchronized(SingletonDoubleCheckVolatile.class) {
                    if (singletonDoubleCheckVolatile == null) {
                        //调用构造函数可能会存在指令重排，使用volatile
                        singletonDoubleCheckVolatile = new SingletonDoubleCheckVolatile();
                    }
                }
            }
            return singletonDoubleCheckVolatile;
        }
    }

    //2.3 - Java9中使用AtomicReference，避免volatile使得指令的上下部分会指令重排
    static class SingletonAtomicReference {

        private static AtomicReference<SingletonAtomicReference> singletonAtomicReference = new AtomicReference<>();

        private SingletonAtomicReference() {
            System.out.println("耗时长");
            System.out.println("SingletonAtomicReference()");
        }

        public static SingletonAtomicReference getInstance() {
            var localRef = singletonAtomicReference.getAcquire();
            if (localRef == null) {
                synchronized (SingletonAtomicReference.class) {
                    localRef = singletonAtomicReference.getAcquire();
                    if (localRef == null) {
                        singletonAtomicReference.setRelease(new SingletonAtomicReference());
                        localRef = singletonAtomicReference.getAcquire();
                    }
                }
            }
            return localRef;
        }
    }

    //3. 枚举实现，避免使用反射机制构造其他实例
    static enum SingletonEnum {
        INSTANCE;

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

标签：getInstance,实现,汇总,System,private,static,单例,println,out
来源： https://www.cnblogs.com/hello-yz/p/16275573.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。