原创

【java设计模式】单例模式

简单理解单例模式

程序员:“单例模式简单来说就是,每次下雨都买把伞太浪费了,不如买把伞放包里,要用就拿出来,省钱。”
妹纸:“这样做听起来真是太棒了,那为什么不把所有的东西都做成这样呢?”
程序员:“因为这样做也有它的缺陷,比如说妹纸和男朋友一起出门上班,下雨了只有一把伞就不够用道上的黑话叫做共享资源争用,或者线程冲突。”
程序员:“因为伞这种东西是不能两个人共用的(黑话叫线程不安全对象),所以家里只有一把伞就不够了。但是如果是像空调这样大家可以一起用的东西(黑话叫线程安全对象),就可以只买一个,全家人一起用(道上的黑话叫做享元模式)。”
妹纸:“那就让男朋友自己再去买把伞么”
程序员:“这样当然也可以(黑话叫做私有对象),但是要是男朋友搞丢了,伞也一起搞丢了,而且男人嫌麻烦,不喜欢每天揣把伞,图方便干脆要用的时候自己买伞了,还是很浪费。”
妹纸:“这个简单,那就多买几把伞放家里,谁需要就拿去用好了。”程序员:“妹纸你真是太厉害了。这就是牛叉闪闪的对象池模式啊。只有高级程序员才会鼓捣个什么池出来(线程池、连接池),妹纸悟性这么高,要不加入编程这个很有前途的职业吧。。”

一把伞就只能一个人用,程序猿都是凭实力单身

漫画:什么是单例模式?

保证一个类仅有一个实例,并提供一个访问它的全局访问点。

单例模式的作用

  • 对于频繁使用的对象,可以省略创建对象所花费的时间,这对于那些重量级对象而言,是非常可观的一笔系统开销;
  • 由于 new 操作的次数减少,因而对系统内存的使用频率也会降低,这将减轻 GC 压力,缩短 GC 停顿时间。

单例模式的实现方式

  • 饿汉式(线程安全,调用效率高,但是不能延时加载)
  • 懒汉式(线程安全,调用效率不高,但是能延时加载)
  • Double CheckLock实现单例:DCL也就是双重锁判断机制(由于JVM底层模型原因,偶尔会出问题,不建议使用
  • 静态内部类实现模式(线程安全,调用效率高,可以延时加载
  • 枚举类(线程安全,调用效率高,不能延时加载,可以天然的防止反射和反序列化调用)

饿汉式

  • 全局的单例实例在类装载时构建,不管你用不用,先创建了再说。虽然调用的时候省去了判断的时间,但容易产生垃圾对象。
  • 它是线程安全

故事背景:神乐和神威一家是夜兔族,不能见阳光,并且很穷,一家只用得起一把伞。
不管出不出门,都托人先买把伞,用不用伞钱都先花出去了。这就是饿汉式,不支持延迟加载
因为提前买好了伞,没被拿走就用,被拿走了就不用,不用考虑买不买伞的事儿,所以是线程安全的。

例:

创建一个提供伞的类

public class Umbrella {
    // 对外提供一个私有的、static修饰的实例。类初始化时,立即加载这个对象。加载类时,天然的是线程安全的
    private static Umbrella umbrella = new Umbrella();
    // 私有化构造方法
    private Umbrella(){}
    // 对外提供一个静态方法,返回实例
    public static Umbrella getInstance() {
        return umbrella;
    }
}

懒汉式

  • 全局的单例实例在第一次被使用时构建。用的时候再创建。
  • 它是线程不安全

故事背景:神乐和神威一家是夜兔族,不能见阳光,并且很穷,一家只用得起一把伞。
不出门就不买伞,出门的时候托人买把伞,用伞的时候花钱。这就是懒汉式,支持延迟加载
两个人同时要出门,这时候还没伞,都托人买伞,这就是线程不安全

例:

public class Umbrella {
    // 对外提供一个私有的、static修饰的实例
    private static Umbrella umbrella;
    // 构造方法私有化
    private Umbrella(){}
    // 对外提供一个静态方法,返回实例
    public static synchronized Umbrella getUmbrella() {
        if (umbrella == null) {
            umbrella = new Umbrella();
        }
        return umbrella;
    }
}

双重检测加锁(懒汉式)

  • 首先检查是否实例已经创建,如果尚未创建,才进行同步。这样以来,只有一次同步,这正是我们想要的效果。
  • 它是线程安全

故事背景:神乐和神威一家是夜兔族,不能见阳光,并且很穷,一家只用得起一把伞。
不出门就不买伞,出门的时候托人买把伞,用伞的时候花钱。这就是懒汉式,支持延迟加载
两个人同时要出门,这时候如果还没伞,就托人买伞,这是第一重检测。找到一个跑腿的人,跑腿的一次只给一个人说话,这就是synchronized 加锁,再次确认一下没有伞后才让跑腿的去买伞,这是第二重检测。经过上面一道道把关,不会出现买两把伞的情况,这就是线程安全

public class Umbrella {
    // 对外提供一个私有的、static修饰的实例
    private static Umbrella umbrella;
    // 构造方法私有化
    private Umbrella(){}
    // 对外提供一个静态方法,返回实例
    public static Umbrella getUmbrella(){
        // 检查实例,如果不存在则进入同步代码块
        if (umbrella == null){
            // 只有第一次才彻底执行这段代码
            synchronized (Umbrella.class){
                // 进入同步代码块后如果仍是null,则创建实例
                if (umbrella == null){
                    umbrella = new Umbrella();
                }
            }
        }
        return umbrella;
    }
}

静态内部类(懒汉式)

  • 外部类没有 static 属性,不会像饿汉式那样立即加载对象
  • 只有真正调用 getInstance() 方法时,才会调用静态内部类。加载类时是线程安全的,instance 是 static final 类型,保证了内存中只有这样一个实例存在,而且只被赋值一次,从而保证了线程安全
  • 兼备了并发高效调用和延迟加载的优势

故事背景:神乐和神威一家是夜兔族,不能见阳光,并且很穷,一家只用得起一把伞。。。
还记得那个跑腿的吗,这次直接让他花自己的钱先买把伞,这样就保证了不用自己先掏钱买伞,出门的时候再向这个跑腿的买伞,这就是延迟加载。而跑腿的只有一把伞,这就是线程安全

public class Umbrella {
    private static class UmbreallaHolder{
        private static final Umbrella UMBRELLA = new Umbrella();
    }
    private Umbrella(){}
    public static final Umbrella getUmbrella(){
        return UmbreallaHolder.UMBRELLA;
    }
}

枚举方式(饿汉式)

这种方式是 Effective Java 作者 Josh Bloch 提倡的方式,它不仅能避免多线程同步问题,而且还自动支持序列化机制,防止反序列化重新创建新的对象

这个我编不来了、、

public enum Singleton {
    INSTANCE;
    public void doSomething() {
        System.out.println("枚举方法实现单例");
    }

    public static void main(String[] args) {
        Singleton s1 = Singleton.INSTANCE;
        Singleton s2 = Singleton.INSTANCE;
        s1.doSomething();
        s2.doSomething();
        System.out.println(s1 == s2);
    }
}

理解浅薄,上面强行用故事来打比方说的不一定对,还请大神指正。

正文到此结束
本文目录