实现singleton的四种方法-创新互联

这篇文章主要为大家详细介绍了实现singleton的四种方法,文中示例代码介绍的非常详细,零基础也能参考此文章,感兴趣的小伙伴们可以参考一下。

创新互联公司是专业的邛崃网站建设公司,邛崃接单;提供网站设计、成都网站制作,网页设计,网站设计,建网站,PHP网站建设等专业做网站服务;采用PHP框架,可快速的进行邛崃网站开发网页制作和功能扩展;专业做搜索引擎喜爱的网站,专业的做网站团队,希望更多企业前来合作!

消耗内存最严重的对象创建过程,必须对其进行约束,作为创建型模式的单例模式(Singleton),始终保持应用程序中某一个实例有且仅有一个,可以很显著的提升程序性能。

 单线程下的Singleton的稳定性是极好的,可分为两大类:

1.Eager(饿汉型): 类加载时立即创建对象。

public class EagerSingleton {
    //1. 类加载时就立即产生实例对象,通过设置静态变量被外界获取
    //2. 并使用private保证封装安全性
    private static EagerSingleton eagerSingleton  = new EagerSingleton();
    
    //3. 通过构造方法的私有化,不允许外部直接创建对象,确保单例的安全性
    private EagerSingleton(){
    }
    public static EagerSingleton getEagerSingleton(){
        return eagerSingleton;
    }

2.Lazy(懒汉型):类加载时没有立即创建对象,等到第一个用户获取才进行实例化。

public class LazySingleton {
    //1. 类加载时并没有创建唯一实例
    private static LazySingleton lazySingleton;
    
    private LazySingleton() {
    }
        
    //2、提供一个获取实例的静态方法
    public static LazySingleton getLazySingleton() {
        if (lazySingleton == null) {
            lazySingleton = new LazySingleton();
        } 
        return lazySingleton;
    }

就性能方面而言,LazySingleton 明显优于 EagerSingleton ,若类的加载需要耗费大量的资源(e.g. 读取大文件信息),那么LazySingleton 的优势显而易见。但通过阅读代码,很容易发现一个致命问题。多线程间如何保持安全性?

下面将对多线程并发问题进行解析:

解决该问题的关键在于两方面:1.同步;  2.性能;

如何解救呢?
作为一个java的开发者,对synchronized一定不陌生,提到多线程,大部分人想到的都是他(JDK6后,他的性能提升巨大,解决简单并发,非常适用)。

那就让我们用synchronized来尝试解决吧:

//由synchronized进行同步加锁
public synchronized static LazySingleton getLazySingleton() {
        if (lazySingleton == null) {
            lazySingleton = new LazySingleton();
        } 
        return lazySingleton;
    }

如此同步问题看似解决,但是作为一个开发者,最重要的是性能的保障,使用synchronized有利有弊,由于加锁操作,代码段被加上悲观锁,只有等一个请求完成,下个请求才能进入执行。通常加上synchronized关键字的代码片会比同等量级的代码慢上几倍,这是我们不愿见到的。那如何避免这一问题呢?在java对synchronized的定义里有这样的建议:越迟使用synchronized,性能越优(细化锁)。

###### 2.因此,我们需要开始解决性能的问题了。按照synchronized优化: ######

public class DoubleCheckLockSingleton {
    //使用volatile保证每次取值不是从缓存中取,而是从真正对应的内存地址中取.(下文解释)
    private static volatile DoubleCheckLockSingleton doubleCheckLockSingleton;
    
    private DoubleCheckLockSingleton(){
        
    }
    
    public static DoubleCheckLockSingleton getDoubleCheckLockSingleton(){
        //配置双重检查锁(下文解释)
        if(doubleCheckLockSingleton == null){
            synchronized (DoubleCheckLockSingleton.class) {
                if(doubleCheckLockSingleton == null){
                    doubleCheckLockSingleton = new DoubleCheckLockSingleton();
                }
            }
        }
        return doubleCheckLockSingleton;
    }
}

上述源码就是经典的volatile关键字(JDK1.5 后重生)+双重检查锁(DoubleCheck),大程度的优化了sychronized带来的性能开销。下面将为大家解释volatile与DoubleCheck。

1.volatile

是在JDK1.5后才正式被实现使用的,之前的版本只是定义了该关键字,未有具体实现。若想理解volatile就必须对JVM自身的内存管理有些许了解:

1.1 遵循着摩尔定律,内存的读写速度已远不能满足CPU,因此现代计算机引入了在CPU上添加高速缓存的机制,由缓存预读取内存的值,并暂存于缓存中,通过计算,再更新内存中的相应值。

**1.2** 而JVM模仿PC的这一做法,在内存中划分了自己的**工作内存**,该部分内存作用与高速缓存一致,很显著的提高JVM工作效率,但凡事都有利有弊,这一做法也导致工作内存与其他内存通信时容易导致传输上的问题。volatile的一个功能就是强制的从内存中读取最新的值,避免缓存与内存不一致的状况。

1.3 volatile的另一个功能也是和JVM相关,即JVM会通过自身的判断,将源码的执行顺序重排,保证指令流水线连贯性,以达到最优的执行方案。这种做法提高了性能,但对DoubleCheck却会产生意想外的结果,两线程可能互相干扰。而volatile提供了happens-before guarantee(写优先于读),使对象不被干扰,保证安全的稳定性。

2.DoubleCheck

这是现代编程的遗留,假设进入同步块之后,对象已被实例化,此时需再次进行判断。

当然还有一种官方推荐的单例实现方法

由于类的构造在定义中已是原子性的,因此上述的各种问题都不会再产生,是一种很好的单例实现方式,推荐使用。

//使用内部类进行单例构造
public class NestedClassSingleton {
    private NestedClassSingleton(){
        
    }
    private static class SingletonHolder{
        private static final NestedClassSingleton nestedClassSingleton = new NestedClassSingleton();
    }
    public static NestedClassSingleton getNestedClassSingleton(){
        return SingletonHolder.nestedClassSingleton;
    }
}

看完上述内容,你们掌握实现singleton的四种方法的方法了吗?如果还想学到更多技能或想了解更多相关内容,欢迎关注创新互联行业资讯频道,感谢各位的阅读!


当前名称:实现singleton的四种方法-创新互联
网站URL:http://scyanting.com/article/hpjco.html