523c79d38dbc9f2527a896129653bdf0
5分钟理解设计模式 —— 单例模式

[TOC]

概述:

  5分钟理解设计模式系列,将通过解决实际问题,来带您理解设计模式,本文希望带您搞懂的3个问题是:
1. 为什么使用单例模式?
2.你有哪些实现单例模式的方法?
3.单例模式是[金手指]吗?

1 为什么使用单例模式?

  单例模式(Singleton Design Pattern),一个类只允许创建一个对象(或者实例),这个类就是一个单例类,这种设计模式,就叫做单例模式。
  单例模式主要用于:处理资源访问冲突表示全局唯一

处理资源访问

  例如:我们有一个Logger类,通过FileWriter类来记录日志,记录日志的文件位置是:info.log,我们在程序中可能会有很多地方需要记录日志,那么如果我们每一次记录日志,都创建一个Logger类的话,那么每一个Logger类都会去写info.log文件(每个Logger对应一个FileWriter,多个FileWriter同时写入),此时info.log就是一个竞争资源,两个线程同时写入数据,就可能出现数据覆盖的情况。但是如果Logger类是一个单例类,那么由于FileWriter是一个线程安全的对象,那么就不会出现数据覆盖的问题。

表示全局唯一

  在我们的程序开发过程中,有一些类需要被表示成全局唯一,比如我们的配置文件在系统中只有一份,那么当配置文件被加载到内存后,以对象的形式存在,也应该存一份,再比如全局的id自增生成器、线程池、对象池等对象,也可以设计成单例。

2 你有哪些实现单例模式的方法?

1 饿汉式:

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

  在类加载的时候,创建对象,有人觉得这种实现方式不好,因为不支持延迟加载。
  但是我并不认同这种说法,因为如果该对象加载耗时非常长,那么最好不要等到真正去使用它的时候,再去初始化,因为这样会影响性能,甚至会由于接口响应时间过长导致超时失败。如果该实力占用资源较多,可能会引起程序报错(比如 Java 中的 PermGen Space OOM),那么在程序初始化时抛出异常,我们还可以进行调整,但是如果这个异常是在程序运行时抛出的,那么会导致整个程序崩溃,所以有问题应该提早暴露,遵循fail-fast的设计原则

2 双重检测懒汉式

public class Singleton {
    private Singleton() {
    }
    private static Singleton singleton = null;
    public Singleton getInstance(){
        // 提高性能,降低线程进入临界区的可能
        if(singleton == null){
            synchronized (Singleton.class){
                if(singleton == null){
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

  这也是单例模式比较经典的写法,网上有人说由于指令重排,需要在加volatile关键字,禁止指令重排。实际上这个问题在高版本的jdk中已经修复了,修复方法是将对象的new操作改成原子操作。低版本的指令重排问题产生的原因我也写在了文章的最后,感兴趣的同学也可以了解一下。

3 静态内部类

这是一种比双重检测的单例模式更简单的写法,也可以做到延迟加载:

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

  该方法使用的是静态内部类的特性,外部类被加载的时候,不会创建Inner实例对象,只有调用 getInstance方法的时候,才会创建Sigleton对象,创过程中的线程安全,Singleton的唯一性均由JVM保证

4 枚举

枚举是一种最简单的实现方式,通过java枚举类的特性,保证唯一性。

public enum Singleton  {
    INSTANCE 
    //doSomething 该实例支持的行为
    //可以省略此方法,通过Singleton.INSTANCE进行操作
    public static Singleton get Instance() {
        return Singleton.INSTANCE;
    }
}

3 单例模式是[金手指]吗?

并不是,单例模式也存在着一些问题
对OOP的特性不友好(不基于接口、对继承、多态并不友好)
不支持有参数的构造函数
对程序的可测试性不友好
对程序的扩展性不友好
如果单例模式的成员变量是全局变量,一但被修改将影响其他调用类
所以我们可以用过工厂模式、或者是ioc容器来代替单例模式,当然使用那种对象创建方法,还应该根据具体的业务而定。

选读:低版本的jdk为什么需要使用到volatile关键字修饰?

public class Singleton {
    private Singleton() {
    }
    private volatile Singleton singleton = null;
    public Singleton getInstance(){
        // 提高性能,降低线程进入临界区的可能
        if(singleton == null){
            synchronized (Singleton.class){
                if(singleton == null){
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

代码中有两处判空:
  第一处判空,是为了提高性能,降低线程进入临界区的可能性。
  第二处判空是为了线程同步,假如没有第二处判空,则可能两个线程都通过了if(singleton==null)条件,这样即使是临界区内只有一个线程在执行,临界区内的代码也会被执行两遍,这样就会产生两个对象,不符合单例模式。
  成员变量使用了volatile进行修饰,一方面是保证了对象在多线程环境下的可见性,另一方面是为了防止new Singleton()进行指令重排序而导致的并发问题。
  volatile关键字的作用两个:
  1 保证变量在线程之间的可见性(直接从主存中读写数据,不经过工作内存)
  2 阻止编译时和运行时的指令重排,编译时JVM编译器遵循内存屏障约束,运行时依赖CPU屏障来阻止指令重排。
  指令重排是指JVM在编译Java代码的时候,或者CPU在执行JVM字节码的时候,对现有的指令顺序进行重新排序。
  指令重排的目的是为了在不改变程序执行结果的前提下,优化程序的运行效率。需要注意的是,这里所说的不改变执行结果,指的是不改变单线程下的程序执行结果。
  这里不太好懂,举一个例子,正常的new Singleton()创建步骤是:
  1 开辟一块内存空间
  2 创建对象
  3 将对象的地址存入引用变量
  经过指令重排后,可能变成了:
  1 开辟一块内存空间
  2 将对象的地址存入引用变量
  3 创建对象
  假设发生了指令重排,线程A、B都执行这段代码,线程A执行到了new Singleton()的步骤2,此时还没有创建对象,这个时候发生了线程的切换。线程B开始执行,这个时候线程B还可以通过if(singleton == null)的判断,因为线程A中的singleton只是指向了一个空的内存地址,这个时候线程B创建出了一个Singleton对象,当线程切换成A时,线程A仍执行了new Singleton()的步骤3,此时创建了2个Singleton对象,不符合单例模式。

最后,期待您的订阅和点赞,专栏每周都会更新,希望可以和您一起进步,同时也期待您的批评与指正!

© 著作权归作者所有
这个作品真棒,我要支持一下!
一个坚持原创的小专栏。分享编程知识,提升工作效率,致力于通过简单的语言,把编程这点事讲清楚。涵盖内容:java、设...
0条评论
top Created with Sketch.