深入学习单例模式

MrPeng1991

已于 2024-07-05 01:19:43 修改

阅读量1.1w

点赞数 20

分类专栏： java学习文章标签：单例模式 java 开发语言

于 2017-12-01 18:13:30 首次发布

本文链接：https://blog.csdn.net/gangjindianzi/article/details/78689713

版权

java学习专栏收录该内容

16 篇文章 0 订阅

订阅专栏

深入学习单例模式

1.饿汉式单例
2.懒汉式单例
3.懒汉式加锁
4.double-checked locking 双重检查模式锁（DCL）
5.基于类初始化实现多线程环境中的单例模式

单例保证一个类只有一个实例，并提供一个访问它的全局访问点。
好处是，减少内存开销，，避免频繁创建和销毁实例。
加载，表示启动程序的文件或信息的存入内存

java中类的字节码文件加载进内存，就是内容以io流的形式存入内存。

User user=new User(“男”，26)；
该语句做了几件事：

因为new用到了User.class，所以找到User.class文件并加载到内存中
执行该类的static代码块，如果有的话，给User.class类进行初始化
在堆内存中开辟空间，分配内存地址。
在堆内存中建立对象的特有属性，并进行默认初始化。
对属性进行显式初始化
对对象进行构造代码块初始化
对对象进行对应的构造函数初始化
将内存地址赋给栈内存中的p变量

简化为三步

分配对象内存
调用构造器方法，执行初始化
将对象赋值给变量
虚拟机实际运行时，以上代码2 3可能发生重排序，但是并不会重排序1这个指令，因为23都需要依托1指令的执行结果。

Java 语言规规定了线程执行程序时需要遵守 intra-thread semantics。 **intra-thread semantics ** 保证重排序不会改变单线程内的程序执行结果。这个重排序在没有改变单线程程序的执行结果的前提下，可以提高程序的执行性能。

虽然重排序并不影响单线程内的执行结果，但是在多线程的环境出现内存可见性问题。

1.饿汉式单例

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

这样的代码缺点是：第一次加载类的时候会连带着创建Singleton实例，这样的结果与我们所期望的不同，因为创建实例的时候可能并不是我们需要这个实例的时候。同时如果这个Singleton实例的创建非常消耗系统资源，而应用始终都没有使用Singleton实例，那么创建Singleton消耗的系统资源就被白白浪费了，类加载时完成初始化，类加载较慢，但获取对象速度快。

为了避免这种情况，我们通常使用惰性加载的机制，也就是在使用的时候才去创建。以上代码的惰性加载代码如下：

2.懒汉式单例

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

线程安全问题

这是如果两个线程A和B同时执行了该方法，然后以如下方式执行：

A进入if判断，此时instance为null，因此进入if内
B进入if判断，此时A还没有创建instance，因此instance也为null，因此B也进入if内
A创建了一个instance并返回
B也创建了一个instance并返回

此时问题出现了，我们的单例被创建了两次，而这并不是我们所期望的。

3.懒汉式加锁

以上问题最直观的解决办法就是给getInstance方法加上一个synchronize前缀，这样每次只允许一个现成调用getInstance方法：

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

这种解决办法的确可以防止错误的出现，但是它却很影响性能：每次调用getInstance方法的时候都必须获得Singleton的锁，而实际上，当单例实例被创建以后，其后的请求没有必要再使用互斥机制了，造成不必要的同步开销，不建议使用。

4.double-checked locking 双重检查模式锁（DCL）

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

这种写法在getSingleton方法中对singleton进行了两次判空，第一次是为了不必要的同步，第二次是在singleton等于null的情况下才创建实例。在这里用到了volatile关键字，双重检查模式是正确使用volatile关键字的场景之一。
在这里使用volatile会或多或少的影响性能，但考虑到程序的正确性，牺牲这点性能还是值得的。 DCL优点是资源利用率高，第一次执行getInstance时单例对象才被实例化，效率高。缺点是第一次加载时反应稍慢一些，在高并发环境下也有一定的缺陷，虽然发生的概率很小。DCL虽然在一定程度解决了资源的消耗和多余的同步，线程安全等问题，但是他还是在某些情况会出现失效的问题，也就是DCL失效，在《java并发编程实践》一书建议用静态内部类单例模式来替代DCL。如果不加volatile，就出现了文章开头的内存可见性问题。

A、B线程同时进入了第一个if判断
A首先进入synchronized块，由于instance为null，所以它执行instance = new Singleton();
JVM先画出了一些分配给Singleton实例的空白内存，并赋值给instance成员，由于JVM内部的优化机制（重排序），注意此时JVM没有开始初始化这个实例，此时intance已经不为null,
B进来，由于instance此时不是null，因此它return instance。
B线程打算使用Singleton实例，却发现它没有被初始化，于是空指针异常。

volatile作用

保证可见性，使用volatile定义的变量，将会保证对所有线程可见性
禁止指令重排序优化。
注意，volatile不能保证原子性
这里由于禁止对象创建时指令重排序，所以其他线程不会访问到一个未初始化的对象。
https://www.infoq.cn/article/java-memory-model-1/?utm_source=infoq&utm_medium=related_content_link&utm_campaign=relatedContent_articles_clk

https://blog.csdn.net/javageektech/article/details/99619318
https://blog.csdn.net/itachi85/article/details/51480553
https://www.infoq.cn/news/double-checked-locking-with-delay-initialization

5.基于类初始化实现多线程环境中的单例模式

为了实现慢加载，并且不希望每次调用getInstance时都必须互斥执行，最好并且最方便的解决办法如下：

public class Singleton{        
    private Singleton(){        
        …        
    }        
    private static class SingletonContainer{        
        private static Singleton instance = new Singleton();        
    }        
    public static Singleton getInstance(){        
        return SingletonContainer.instance;        
    }        
}

JVM内部的机制能够保证当一个类被加载的时候，这个类的加载过程是线程互斥的。（JVM在类的初始化阶段（即在Class被加载后，且被线程使用之前），会执行类的初始化。在执行类的初始化期间，JVM会去获取一个锁。这个锁可以同步多个线程对同一个类的初始化。相比其他实现方案（如double-checked locking等），该技术方案的实现代码较为简洁，并且在所有版本的编译器中都是可行的。）这样当我们第一次调用getInstance的时候，JVM能够帮我们保证instance只被创建一次，并且会保证把赋值给instance的内存初始化完毕，这样我们就不用担心上述中的问题。此外该方法也只会在第一次调用的时候使用互斥机制，这样就解决了上述中的低效问题。最后instance是在第一次加载SingletonContainer类时被创建的，而SingletonContainer类则在调用getInstance方法的时候才会被加载，因此也实现了惰性加载。
静态内部类是不是完美的呢？也不是，就是传参的问题，由于是静态内部类的形式去创建单例的，故外部无法传递参数进去，这时候用DCL+volatile就好