java单例设计模式以及在android上面的应用

2024年2月5日 185次阅读 来源: 草丛伦

关于java的单例设计模式，是项目当中很常用的设计模式。当某个资源，或者某个实例 ，整个项目只使用一份的情况下，我们就需要用这个去创建一个单例，例如工具类等，都是要用到这种模式的。项目中对于这些工具类，往往只需要维持一个对象，然后一直用这个对象就可以了，以此减少内存的开支。

class SingleTonClass {
    //饿汉式单例模式 提前创建对象
    private static SingleTonClass singleTonClass = new SingleTonClass();

    private SingleTonClass() {
    }

    public static SingleTonClass getInstance() {
        return singleTonClass;
    }
}

class SimpleClass {
  //懒汉式单例模式 等到需求时再去判断是否需要创建对象
    private static SimpleClass simpleClass;
    private SimpleClass() {
    }
    public static SimpleClass getInstance() {
        if (simpleClass == null) {//懒汉式 
            simpleClass = new SimpleClass();
        }
        return simpleClass;
    }
}

上述写法，如果在线程并发执行的状态下，很可能会出现多个实例被创建。
所以我们可以改造getInstance（）方法，去适应多线程情况。

  public static SimpleClass getInstance() {
        if (simpleClass == null) {
            synchronized (SimpleClass.class) {//减小同步区域 更好的优化性能
                if (simpleClass == null) {
                    simpleClass = new SimpleClass();
                }
            }
        }
        return simpleClass;
    }

双重锁定使得这个函数更加的安全，但是依然有问题
因为simpleClass = new SimpleClass();这段代码 ，并不是原子性操作，他包含好几个步骤：

  1. 为对象分配内存
  2. 初始化实例对象
  3. 把引用instance指向分配的内存空间

这个三个步骤并不能保证按序执行，处理器会进行指令重排序优化，存在这样的情况：

优化重排后执行顺序为：1,3,2, 这样在线程1执行到3时，instance已经不为null了，线程2此时判断instance!=null，则直接返回instance引用，但现在实例对象还没有初始化完毕，此时线程2使用instance可能会造成程序崩溃。
现在要解决的问题就是怎样限制处理器进行指令优化重排。
答案就是用volatile关键字 ，他提供了线程之间修改可见性。

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

解释一下volatile关键字：

1.保证可见性

可以保证在多线程环境下，变量的修改可见性。每个线程都会在工作内存（类似于寄存器和高速缓存），实例对象都存放在主内存中，在每个线程要使用的时候把主内存中的内容拷贝到线程的工作内存中。使用volatile关键字修饰后的变量，保证每次修改了变量需要立即写回主内存中，同时通知所有的该对变量的缓存失效，保证缓存一致性，其他线程需要使用该共享变量时就要重新从住内存中获取最新的内容拷贝到工作内存中供处理器使用。这样就可以保证变量修改的可见性了。但volatile不能保证原子性，比如++操作。

2.提供内存屏障

volatile关键字能够通过提供内存屏障，来保证某些指令顺序处理器不能够优化重排，编译器在生成字节码时，会在指令序列中插入内存屏障来禁止特定类型的处理器重排序。

下面是保守策略插入内存屏障：

    在每个volatile写操作的前面插入一个StoreStore屏障。

    在每个volatile写操作的后面插入一个StoreLoad屏障。

    在每个volatile读操作的前面插入一个LoadLoad屏障。

    在每个volatile读操作的后面插入一个LoadLoad屏障。

这样可以保证在volatile关键字修饰的变量的赋值和读取操作前后两边的大的顺序不会改变，
在内存屏障前面的顺序可以交换，屏障后面的也可以换序，但是不能跨越内存屏障重排执行顺序。
好了，现在来看上面的单例模式，这样就可以保证3步骤（instance赋值操作）是保持最后一步完成，
这样就不会出现instance在对象没有初始化时就不为null的情况了。这样也就实现了正确的单例模式了。

还有一种枚举，也是单例模式的实现：

    public enum SingleEnum{  
        INSTANCE;  //不建议用 
    }

关于单例模式在android方面的应用：
单例模式一般运用在一些工具类上面。还有，界面之间传输数据，有可能会因为数据量太大，造成TransactionTooLargeException异常的，所以这个时候，就需要通过一个帮助类去存储这段数据，为了保证数据的正确性，这个时候必定就是要用到单例模式的。

    原文作者：草丛伦
    原文地址: https://www.jianshu.com/p/9b4e4133b359
    本文转自网络文章，转载此文章仅为分享知识，如有侵权，请联系博主进行删除。
点赞