美文网首页
并发情况下,单例模式的的4种处理

并发情况下,单例模式的的4种处理

作者: 小小浪把_Dont_know拍 | 来源:发表于2017-10-04 21:20 被阅读97次

    背景

    众所周知,单例模式主要就是将构造函数声明为private,来防止外部调用实例化。代码如下:

    public class Singleton {
        private static Singleton uniqueInstance;
    
        private Singleton() {}
    
        public static Singleton getInstance() {
            if (uniqueInstance == null) {
                uniqueInstance = new Singleton();
            } 
            return uniqueInstance;
        }
    }
    

    这段逻辑,在单线程的程序中工作得很好。但是,当引入多线程时,就可能会出现问题。

    示意图如下:


    示意图

    那么该如何解决呢

    1.加上同步锁

    使用synchroinzed关键字,使程序在执行时,同一时刻,只有一个线程执行getInstance方法。

    public class Singleton {
        private static Singleton uniqueInstance;
    
        private Singleton() {}
    
        public static synchronized Singleton getInstance() {
            if (uniqueInstance == null) {
                uniqueInstance = new Singleton();
            } 
            return uniqueInstance;
        }
    }
    

    适用场景:
    getInstance的性能对应用程序不是关键。因为这种方法会严重降低性能,而且只有第一次执行getInstance方法的时候,才需要同步。之后所有执行此方法时,都不需要同步锁了。(个人觉得,用了synchronized后,只有在未初始化的时候,性能影响会比较大。之后所有执行次方法,只是直接返回实例了,所以对性能影响有限)

    2.使用饿汉模式

    在应用程序声明这个类的时候,就执行实例化。

    public class Singleton {
        private static Singleton uniqueInstance = new Singleton();
    
        private Singleton() {}
    
        public static Singleton getInstance() {
            return uniqueInstance;
        }
    }
    

    适用场景:
    如果应用程序总是创建并使用单例模式,或者在创建和运行时方面的负担不太繁重。它是最简单、最清楚的替代方法。

    静态初始化器如何保证实例只会被创建一次?

    刚开始,我以为静态方法在程序启动时,会加载所有类的静态初始化器,从而保证实例只会有一个。

    public class Singleton {
        private static Singleton uniqueInstance = new Singleton();
    
        private Singleton() {
            System.out.println("create ins");
        }
    
        public static Singleton getInstance() {
            return uniqueInstance;
        }
    }
    public class Main {
    
        public static void main(String[] args) {
            System.out.println("main");
            Singleton.getInstance();
        }
    }
    

    这段程序实际的执行结果却是:
    main
    create ins
    原来,静态初始化器是保证线程安全的。在每次加载类的时候才会去执行静态初始化器。一个类只会被加载一次,如果一个类被加载了两次,运行时类名就会冲突了。所以jvm会保证静态初始化器是线程安全的。

    3.双重检查加锁

    首先检查是否实例已经创建了,如果尚未创建,才进行同步。这样一来,只有第一次会同步。

    public class Singleton {
        private volatile static Singleton uniqueInstance;
    
        private Singleton() {}
    
        public static Singleton getInstance() {
            if (uniqueInstance == null) {
                synchronized (Singleton.class) {
                    if (uniqueInstance == null) {
                        uniqueInstance = new Singleton();
                    }
                }
            }
            return uniqueInstance;
        }
    }
    

    Volatile

    Volatile是轻量级的synchronized,它在多处理器开发中保证了共享变量的“可见性”。可见性的意思是当一个线程修改一个共享变量时,另外一个线程能读到这个修改的值。

    适用场景:
    java 5及以后的版本才支持。如果性能死你关心的重点,可以使用这种方法。实例域推荐使用这种方法,静态域推荐使用第4种方法。

    4.lazy initialization holder class

    public class Singleton {
        private static class SingletonHolder {
            static final Singleton singleton  = new Singleton();
        }
    
        public static Singleton getInstance() {
            return SingletonHolder.singleton;
        }
    }
    

    适用场景:
    处于性能的考虑而需要对静态域使用延迟初始化。

    相关文章

      网友评论

          本文标题:并发情况下,单例模式的的4种处理

          本文链接:https://www.haomeiwen.com/subject/nnncyxtx.html