最全面的单例模式

最新推荐文章于 2024-08-10 16:13:20 发布

向上啊-up

最新推荐文章于 2024-08-10 16:13:20 发布

阅读量162

点赞数

分类专栏：学习文章标签： java 设计模式

本文链接：https://blog.csdn.net/qq_40675750/article/details/106363555

版权

学习专栏收录该内容

6 篇文章 0 订阅

订阅专栏

设计模式之单例模式

简介

单例模式，是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中，使用单例模式的类只有一个对象实例。

单例应用场景

1、Windows系统的任务管理器。
2、Windows系统的回收站。
3、操作系统的文件系统，一个操作系统只能有一个文件系统。
4、数据库连接池的设计与实现。
5、多线程的线程池设计与实现。
6、Spring中创建的Bean实例默认都是单例。
7、Java-Web中，一个Servlet类只有一个实例。
8、等等…

单例的优缺点

优点
一、实例控制

单例模式会阻止其他对象实例化其自己的单例对象的副本，从而确保所有对象都访问唯一实例。

二、灵活性

因为类控制了实例化过程，所以类可以灵活更改实例化过程。

缺点
一、开销

虽然数量很少，但如果每次对象请求引用时都要检查是否存在类的实例，将仍然需要一些开销。可以通过使用静态初始化解决此问题。

二、可能的开发混淆

使用单例对象（尤其在类库中定义的对象）时，开发人员必须记住自己不能使用new关键字实例化对象。因为可能无法访问库源代码，因此应用程序开发人员可能会意外发现自己无法直接实例化此类。

三、对象生存期

不能解决删除单个对象的问题。在提供内存管理的语言中（例如基于.NET Framework的语言），只有单例类能够导致实例被取消分配，因为它包含对该实例的私有引用。在某些语言中（如 C++），其他类可以删除对象实例，但这样会导致单例类中出现悬浮引用。。

实现单例的几种方式

一、饿汉式

 * 1、构造器私有化
 * 2、自行创建，并且静态变量保存
 * 3、向外提供这个实例
 * 4、强调这是一个单例可以，直接使用final
public class Singleton1 {


    public static  final Singleton1 INSTANCE=new Singleton1();
    private Singleton1() {
    }

}

public class test {

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

在这里插入图片描述
总结：线程安全、非懒加载、效率高。

是否推荐：可以使用，但不推荐。

二、懒汉式

/**
 * 懒汉式：
 *    延迟加载这个实例对象
 *
 *    1、构造器私有
 *    2、用一个静态变量保存这个唯一的实例
 *    3、提供一个静态方法，获取这个实例对象
 */
 public class Singleton2 {
    private static Singleton2 instance;
    private Singleton2() {
    }

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

总结：线程安全、懒加载、效率低。

是否推荐：可以使用，但不推荐。

注：该模式还有另一种常见写法，就是把getInstance方法上的synchronized去掉，这种方法有线程安全问题，不能使用。

三、.双重检测机制（DCL）

public class singleton{

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

   return singleton;
  }
 

}

双重检测机制（双重检查加锁），比较常见的一种写法。在第一次使用的时候才进行初始化，达到了懒加载的效果；在进行初始化的时候会进行同步（加锁），因此没有线程安全问题；并且只有第一次进行初始化才进行同步，因此不会有效率方面的问题。

《Java Concurrency in Practice》作者Brian Goetz在书中提到关于DCL的观点：促使DCL模式出现的驱动力（无竞争同步的执行速度很慢，以及JVM启动时很慢）已经不复存在，因而它不是一种高效的优化措施。延迟初始化占位类模式（静态内部类）能带来同样的优势，并且更容易理解。

总结：线程安全、懒加载、效率高。

是否推荐：可以使用。

注：该模式还有另一种常见写法，就是把静态实例singleton的volatile修饰去掉，这种方法有线程安全方面的问题，不能使用。请见下面这个例子。

双重检测机制实现单例（没有volatile修饰）

public class singleton{
   //没有volatile修饰实例
  private static Singleton instance;
  //私有构造
  private Singleton(){}
  
  public static Singleton getInstance(){ //对外提供的工厂方法
  
    if(singleton == null){ //第一次检测
     synchronized(Singleton.class ) {  //同步锁   
     if(singleton == null){ //第二次检测
         singleton =new Singleton(); //初始化
      
       }
  
     }
    }

   return singleton;
  }

这个地方有可能会参数线程不安全的情况，如果是多线程，线程A到了第二次检测 ,线程B到了第一次检测，但是线程A还没有初始化,线程B指向的不再是null，那么这个时候就会产生两个实例！那么如何解决这个问题就是上面那种方法用volatile修饰instance

静态内部类（延迟初始化占位类）

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

}

在内部类被加载和初始化时，才创建INSTANCE实例对象
静态内部类不会自动随着外部类的加载和初始化而初始化，它是单独去加载和初始化的
因为实在内部类加载和初始化时，创建的，因此是线程安全的

总结：线程安全、懒加载、效率高。

是否推荐：推荐使用、《Java Concurrency in Practice》作者Brian Goetz推荐使用的方式

枚举

public enum Singleton2 {
    INSTANCE
}

枚举，不是很常见的一种写法。很简洁的一种实现方式，提供了序列化机制，保证线程安全，绝对防止多次实例化，即使是在面对复杂的序列化或者反射攻击的时候。

总结：线程安全、非懒加载、效率高。

是否推荐：推荐使用、《Effective Java》作者Joshua Bloch推荐使用的方式。

几种方式对比：

方式	优点	缺点
饿汉	线程安全、效率高	非懒加载
懒汉	线程安全、懒加载	效率低
双重检测	线程安全、效率高、懒加载	无
静态内部类	线程安全、效率高、懒加载	无
枚举	线程安全、效率高	非懒加载

可能有人看了以上表格，觉得枚举有缺点，为什么Joshua Bloch还推荐使用枚举？

这就要提到单例的破解了。普通的单例模式是可以通过反射和序列化/反序列化来破解的，而Enum由于自身的特性问题，是无法破解的。当然，由于这种情况基本不会出现，因此我们在使用单例模式的时候也比较少考虑这个问题。

总结：

单例无论是在项目的开发中，还是面试中都是非常常见的，因此需要熟练的掌握好单例的知识。只要记住单例的三个实现要点——私有构造方法、定义静态Singleton实例、暴露实例获取方法，手写这5种实现方式相信都是信手拈来。如果是面试的时候，建议使用静态内部类的实现。
项目中具体使用哪种实现方式可以根据情况而定，个人推荐的方式是：静态内部类和枚举，我自己在项目中常见的也是这两种方式，可能静态内部类会更多一点。另外就是毕竟是两位大神推荐的，还考虑什么，直接用就是了。