【设计模式】单例模式

最新推荐文章于 2023-02-26 23:56:38 发布

小王师傅66

最新推荐文章于 2023-02-26 23:56:38 发布

阅读量184

点赞数

分类专栏：软工-设计模式

本文链接：https://blog.csdn.net/WKX18330698534/article/details/82557209

版权

软工-设计模式专栏收录该内容

14 篇文章 0 订阅

订阅专栏

单例模式，Singleton Pattern,创建型。

一个单一的类，该类创建自己的对象，同时保证只有一个对象被创建。

提供访问其唯一的对象的方式，可直接访问，不需要实例化该类的对象。

关键代码：构造函数是私有的。

大部分时候，都把类的构造器定义为public访问权限，允许任何类自由的创建该类的对象。但在某些时候，允许其他类自由的创建该类的对象没有任何意义，还可能导致系统性能下降（因为频繁的创建对象，回收对象带来的系统开销问题）。例如，一个系统只有一个窗口管理器。

总之，在一些特殊场景下，要求不允许自由创建该类的对象，而只允许为该类创建一个对象，避免其他类自由创建该类的实例，应该把该类的构造器，使用private修饰，从而把该类的所有构造器隐藏起来。

根据封装型的原则：一旦把类的构造器隐藏起来，就需要提供一个public方法作为这个类的访问点，用于创建这个类的对象，且这个方法必须是static修饰（因为调用这个方法之前还不存在对象，因此调用这个方法不可能是对象，只能是类）；

五种单例模式：

懒汉式

线程不安全：

class Singleton
{
    //使用一个变量来缓存曾经创建的实例
    private static Singleton instance;
    //将构造器使用private修饰，隐藏该构造器
    private Singleton(){}
    //提供一个静态方法，用于返回Singleton实例
    //该方法可以加入自定义的控制，保证只产生一个Singleton对象
    public static Singleton getInstance()
    {
         //如果instance为null，表明还不曾创建Singleton对象
         //如果instance不为null，则表明已经创建了Singleton对象，将不会执行该方法
         if (instance == null)
         {
              //创建一个Singleton对象，并将其缓存起来
              instance = new Singleton();
          }
          return instance;
      }
}

public class TestSingleton
{
      public static void main(String[] args)
      {
           //创建Singleton对象不能通过构造器，只能通过getInstance方法
           Singleton s1 = Singleton.getInstance();
           Singleton s2 = Singleton.getInstance();
           //将输出true
           System.out.println(s1 == s2);
       }
}

这种写法lazy loading很明显，但是致命的是在多线程不能正常工作。

线程安全：

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

这种写法能够在多线程中很好的工作，而且看起来它也具备很好的lazy loading，但是，每次调用getInstance方式时，都要去判断锁，效率很低，99%情况下不需要同步

饿汉式

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

这种方式基于classloder机制避免了多线程的同步问题，不过，instance在类装载时就实例化，虽然导致类装载的原因有很多种，在单例模式中大多数都是调用getInstance方法，但是也不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化instance显然没有达到lazy loading的效果。

双重锁校验

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

在JDK1.5之后，双重检查锁定才能够正常达到单例效果

枚举

public enum Singleton{
     INSTANCE;
     public void whateverMethod(){
       System.out.println("something");
     }
}

这种方式是Effective Java作者Josh Bloch 提倡的方式，它不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象，可谓是很坚强的壁垒啊，不过，由于1.5中才加入enum特性，用这种方式写不免让人感觉生疏。

静态内部类

class Singleton{
    private Singleton(){}
    private static class SingletonHolder{
      private static final Singleton instance = new Singleton();
    }
   
    public static final Singleton getInstance(){
       return SingletonHoldler.instance;
    }
   
}

这种方式同样利用了classloder的机制来保证初始化instance时只有一个线程,但Singleton类被装载了，instance不一定被初始化。因为SingletonHolder类没有被主动使用，只有显示通过调用getInstance方法时，才会显式装载SingletonHolder类，从而实例化instance。

各种方法各有利弊，斟酌使用。