单例模式五种实现

羊都是我吃的

前言

文章介绍了单例模式五种实现的方式,分别是懒汉,饿汉,静态内部类,双重检验锁以及枚举实现方式,并主要关心加载时机以及线程安全。首先,通俗点讲,饿汉就是这个类还没被使用到的时候,实例已经创建好了;而懒汉是使用到的时候才创建对应的实例。线程安全方面主要考虑实例化时候是否确保一个实例,对于单例类中其他方法的线程安全不予考虑。

懒汉模式

先来一个最直观的代码:

public class Singleton {

    private static Singleton instance = null;
    private Singleton(){}

    public static Singleton getInstance(){
        //如果还没有被实例化过,就实例化一个,然后返回
        if(instance == null){
            instance = new Singleton();
        }
        return instance;
    }
}

这段代码里,我们没有考虑线程安全,所以可能就会产生多个实例,但是这个例子能很好的表达单例模式的思想,就是保持只有一个实例,先理解了基础,我们再一步步发展。

所以线程安全的事情还是得解决啊~于是有了以下的代码:

public class Singleton {

    private static Singleton instance = null;
    private Singleton(){}

    public static synchronized Singleton getInstance(){
        //如果还没有被实例化过,就实例化一个,然后返回
        if(instance == null){
            instance = new Singleton();
        }
        return instance;
    }
}

这段代码只加了一个关键字synchronized用于确保getInstance方法线程安全,但是这种方式问题很大啊,毕竟所有的线程到了这个方法全得排队等着,对性能的损耗非常大,不过没关系,我们这里着重先解决掉线程安全的问题,接下来会有办法解决这个效率低下的问题(如果你着急那就直接去看双重校验锁吧...)

懒汉模式将实例化的时机放到了需要使用的时候(饿汉是类加载了就有实例),也就是“延迟加载”,相比饿汉,能避免了在加载的时候实例化有可能用不到的实例,但是问题也很明显,我们要花精力去解决线程安全的问题。

饿汉模式

饿汉模式相比懒汉模式,在类加载的时候就已经存在一个实例,举个例子,比如数据库连接吧,懒汉就是第一次访问数据库的时候我才去创建一个连接,而饿汉呢,是你程序启动了,类加载好了的时候,我已经有个连接了,你用不用不一定了,所以饿汉的缺点也就出来了:可能会产生很多无用的实例。

public class Singleton {
    //类加载的时候instance就已经指向了一个实例
    private static Singleton instance = new Singleton();
    private Singleton(){}

    public static Singleton getInstance(){
        return instance;
    }
}

那么加载时机的问题我们已经说过了,接下来就是线程安全了,代码里我们并没有看见synchronized关键字,那么这种方式是如何确保线程安全的呢,这个就是JVM类加载的特性了,JVM在加载类的时候,是单线程的,所以可以保证只存在单一的实例。

双重校验锁

首先要说明的是,双重检验锁也是一种延迟加载,并且较好的解决了在确保线程安全的时候效率低下的问题。

public class Singleton {
    
    private static Singleton instance = null;
    private Singleton(){}

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

对比一下最原始的那种线程安全的方法(就是懒汉模式的第二种代码),那种方法将整个getInstance方法锁住,那么每次调用那个方法都要获得锁,释放锁,等待等等...而双重校验锁锁住了部分的代码。进入方法如果检查为空才进入同步代码块,这样很明显效率高了很多。
有人疑问为什么instance==null要判断两次吗,那我们先去掉第二次的判断。
如果两个线程一起调用getInstance方法,并且都通过了第一次的判断instance==null,那么第一个线程获取了锁,然后实例化了instance,然后释放了锁,然后第二个线程得到了线程,然后马上也实例化了instance,这就尴尬了。单例模式就失败了。
所以加上第二次判断后,先进来的线程判断了一下,哦,为空,我创建一个,然后创建一个实例之后释放了锁,第二个线程进来之后,哎?已经有了,那我就不用创建了,然后释放了锁,开开心心的完成了单例模式。

静态内部类

懒汉模式需要考虑线程安全,所以我们多写了好多的代码,饿汉模式利用了类加载的特性为我们省去了线程安全的考虑,那么,既能享受类加载确保线程安全带来的便利,又能延迟加载的方式,就是静态内部类。Java静态内部类的特性是,加载的时候不会加载内部静态类,使用的时候才会进行加载。而使用到的时候类加载又是线程安全的,这就完美的达到了我们的预期效果~

public class Singleton {

    private static class SingletonHolder{
        private static Singleton instance = new Singleton();
    }

    private Singleton(){}

    public static Singleton getInstance(){
        return SingletonHolder.instance;
    }
}

枚举

JDK1.5提供了一个新的数据类型,枚举。枚举的出现提供了一个较为优雅的方式取代以前大量的static final类型的变量。而这里,我们也利用枚举的特性,实现了单例模式,这种思路是《Effective Java》中第三条最后一段给出的实现方式,有兴趣的可以看看这本书~
代码简单到无法理解:

public enum Singleton {
    INSTANCE;
}

外部调用由原来的Singleton.getInstance变成了Singleton.INSTANCE了。

这里要注意,原来的class已经换成了关键字enum,但是其实无所谓的,看下继承关系就能知道,其实还是一个class

clipboard.png

而且我们可以查看Enum的源码:

clipboard.png

这里能看到实现了Serializable接口,所以不用考虑序列化的问题(其实序列化反序列化也能导致单例失败的,但是我们这里不过多研究)。对于线程安全,同样的,加载的时候JVM能确保只加载一个实例。

总结

在单例模式各种设计的方法中,我们使用到了内部静态类的特性,使用了枚举的特性,所以基础非常重要,单例模式是设计模式之一,而设计模式其实是对语言特性不足的一面进一步的包装。吸纳基础,工作学习多加思考,设计模式也就自然而然的能够理解。
另外,好多帖子都说利用枚举的方式在团队合作中不常使用,因为需要配合,用了枚举别人不熟悉。这点我是不同意的,如果因为大家不懂不熟悉而放弃了使用很棒的特性,那么就永远抱着旧的方式停滞不前,JDK的更新也失去了意义。
还是希望能够不断的接触Java新鲜的想法,在深厚的基础上迸发不一样的思路,然后去解决实际的问题。

以上,如有不妥,还望指正。

阅读 15.4k

vipwhr
将来的你,一定会感激现在拼命的自己。

将来的你,一定会感谢现在拼命努力的自己。

1.4k 声望
2.9k 粉丝
0 条评论

将来的你,一定会感谢现在拼命努力的自己。

1.4k 声望
2.9k 粉丝
文章目录
宣传栏