设计模式之单例模式

最新推荐文章于 2024-10-14 13:22:54 发布

小诚信驿站

最新推荐文章于 2024-10-14 13:22:54 发布

阅读量280

点赞数

分类专栏：设计模式文章标签：设计模式单例模式单例模式的10种写法单例模式的枚举写法单例模式的静态类写法单例模式在spring中的应用

设计模式专栏收录该内容

2 篇文章

订阅专栏

本文围绕单例模式展开，介绍其设计要点，即保证类只有一个实例并提供访问点。探讨了Spring中与23种设计模式里单例模式的区别，分析单例模式使用场景、饿汉与懒汉模式差异，还给出实现单例的九种方法。此外，提及Spring中单例bean创建方式，最后对比了SLF4J与Log4j日志框架。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

设计要点：

保证该类只有一个实例。将该类的构造方法定义为私有方法，这样其他处的代码就无法通过调用该类的构造方法来实例化该类的对象
提供一个该实例的访问点。一般由该类自己负责创建实例，并提供一个静态方法作为该实例的访问点，比如日志log4j。（文中最后有补充）

引申Q：spring中的单例模式与23种设计模式中的单例模式有什么区别？
spring中的单例模式完成了后半句话，即提供了全局的访问点BeanFactory。但没有从构造器级别去控制单例，这是因为spring管理的是是任意的java对象。
核心提示点：Spring下默认的bean均为singleton，可以通过singleton=“true|false” 或者 scope="?"来指定。

引申Q：为什么使用单例模式，单例模式使用的场景？

对于系统中的某些类来说，只有一个实例很重要，例如，一个系统只能有一个窗口管理器或文件系统；一个系统只能有一个计时工具或ID（序号）生成器。
同一个jvm应用的不同模块需要使用同一个对象实例进行信息共享。

引申Q：单例有几种模式（饿汉 vs. 懒汉）

饿汉声明实例引用时即实例化
懒汉静态方法第一次被调用前不实例化，也即懒加载。对于创建实例代价大，且不定会使用时，使用懒加载模式可以减少开销

实现单例模式的九种方法

线程不安全的懒汉 - 多线程不可用

public class Singleton {

  private static Singleton INSTANCE;

  private Singleton() {};

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

}
优点：达到了Lazy Loading的效果
缺点：只有在单线程下能保证只有一个实例，多线程下有创建多个实例的风险

同步方法下的懒汉 - 可用，不推荐

public class Singleton {

  private static Singleton INSTANCE;

  private Singleton() {};

  public static synchronized Singleton getInstance() {
    if (INSTANCE == null) {
      INSTANCE = new Singleton();
    }
    return INSTANCE;
  }
}
优点：线程安全，可确保正常使用下（不考虑通过反射调用私有构造方法）只有一个实例
缺点：每次获取实例都需要申请锁，开销大，效率低

同步代码块下的懒汉 - 不可用

public class Singleton {

  private static Singleton INSTANCE;

  private Singleton() {};

  public static Singleton getInstance() {
    if (INSTANCE == null) {
      synchronized (Singleton.class) {
        INSTANCE = new Singleton();
      }
    }
    return INSTANCE;
  }
}
优点：不需要在每次调用时加锁，效率比上一个高
缺点：虽然使用了synchronized，但本质上是线程不安全的。

双重检查（Double Check）下的懒汉 - 推荐

public class Singleton {

  private static volatile Singleton INSTANCE;

  private Singleton() {};

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

}
优点：使用了双重检查，避免了线程不安全，同时也避免了不必要的锁开销。
缺点：NA

但是这里的synchronized已经保证了INSTANCE写操作对其它线程读操作的可见性。具体原理请参考《Java进阶（二）当我们说线程安全时，到底在说什么》
使用volatile关键字的目的不是保证可见性（synchronized已经保证了可见性），而是为了保证顺序性。具体来说，INSTANCE = new Singleton()不是原子操作，实际上被拆分为了三步：1) 分配内存；2) 初始化对象；3) 将INSTANCE指向分配的对象内存地址。如果没有volatile，可能会发生指令重排，使得INSTANCE先指向内存地址，而对象尚未初始化，其它线程直接使用INSTANCE引用进行对象操作时出错。详细原理可参见《双重检查锁定与延迟初始化》

静态常量饿汉 - 推荐

public class Singleton {

  private static final Singleton INSTANCE = new Singleton();

  private Singleton() {};

  public static Singleton getInstance() {
    return INSTANCE;
  }

}
优点：实现简单，无线程同步问题
缺点：在类装载时完成实例化。若该实例一直未被使用，则会造成资源浪费

静态代码块饿汉可用

public class Singleton {

  private static Singleton INSTANCE;
  
  static{
    INSTANCE = new Singleton();
  }

  private Singleton() {};

  public static Singleton getInstance() {
    return INSTANCE;
  }

}
优点：无线程同步问题
缺点：类装载时创建实例，无Lazy Loading。实例一直未被使用时，会浪费资源

静态内部类推荐

public class Singleton {

  private Singleton() {};

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

}
优点：无线程同步问题，实现了懒加载（Lazy Loading）。因为只有调用getInstance时才会装载内部类，才会创建实例。同时因为使用内部类时，先调用内部类的线程会获得类初始化锁，从而保证内部类的初始化（包括实例化它所引用的外部类对象）线程安全。即使内部类创建外部类的实例Singleton INSTANCE = new Singleton()发生指令重排也不会引起双重检查（Double-Check）下的懒汉模式中提到的问题，因此无须使用volatile关键字。
缺点：NA

枚举强烈推荐

public enum Singleton {

  INSTANCE;
  
  // 这里隐藏了一个空的私有构造方法
    private Singleton () {}

  // 该方法非必须，只是为了保证与其它方案一样使用静态方法得到实例
  public static Singleton getInstance() {
    return INSTANCE;
  }

}
优点：枚举本身是线程安全的，且能防止通过反射和反序列化创建多实例。
缺点：使用的是枚举，而非类。
原理： 
枚举类实现其实省略了private类型的构造函数
枚举类的域(field)其实是相应的enum类型的一个实例对象

接口形式的实现方式：
// 定义单例模式中需要完成的代码逻辑
public interface MySingleton {
    void doSomething();
}

public enum Singleton implements MySingleton {
    INSTANCE {
        @Override
        public void doSomething() {
            System.out.println("complete singleton");
        }
    };

    public static MySingleton getInstance() {
        return Singleton.INSTANCE;
    }
}

参考资料1，参考资料2

Spring中单例bean是如何创建的？
Spring中默认配置的bean的scope为singleton，也就是单例作用域。那么看看它是如何做到的。
在AbstractBeanFactory类里面的doGetBean方法：

protected Object doGetBean(
            final String name, final Class requiredType, final Object[] args, boolean typeCheckOnly) throws BeansException {

    final String beanName = transformedBeanName(name);
    Object bean = null;

    // 解决set循环依赖
    Object sharedInstance = getSingleton(beanName);
    if (sharedInstance != null && args == null) {
        ...
    }

    else {
        ...
        // 创建单件bean.
        if (mbd.isSingleton()) {
            sharedInstance = getSingleton(beanName, new ObjectFactory() {
                public Object getObject() throws BeansException {
                    try {
                        return createBean(beanName, mbd, args);
                    }
                    catch (BeansException ex) {
                    ...
                        throw ex;
                    }
                }
            });
            bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
        }
       //创建原型bean
        else if (mbd.isPrototype()) {
            ...
        }
        //创建request作用域bean
        else {
            ...
        }
    }
            ...
    return bean;
}

getSingleton代码：

public Object getSingleton(String beanName, ObjectFactory singletonFactory) {
    Assert.notNull(beanName, "'beanName' must not be null");
    synchronized (this.singletonObjects) {
        Object singletonObject = this.singletonObjects.get(beanName);
        if (singletonObject == null) {
            ...
            beforeSingletonCreation(beanName);
            ...
            try {
                singletonObject = singletonFactory.getObject();
            }
            catch (BeanCreationException ex) {
                ...
            }
            finally {
                if (recordSuppressedExceptions) {
                    this.suppressedExceptions = null;
                }
                afterSingletonCreation(beanName);
            }
            addSingleton(beanName, singletonObject);
        }
        return (singletonObject != NULL_OBJECT ? singletonObject : null);
    }
}

protected void addSingleton(String beanName, Object singletonObject) {
    synchronized (this.singletonObjects) {
        this.singletonObjects.put(beanName, (singletonObject != null ? singletonObject : NULL_OBJECT));
        this.singletonFactories.remove(beanName);
        this.earlySingletonObjects.remove(beanName);
        this.registeredSingletons.add(beanName);
    }
}

private final Map singletonObjects = CollectionFactory.createConcurrentMapIfPossible(16);

可知Spring内部四通过一个ConcurrentMap来管理单件bean的。获取bean时候会先看看singletonObjects中是否有，有则直接返回，没有则创建后放入。

Spring的bean工厂管理的单例模式管理的是多个bean实例的单例，是工厂模式管理所有的bean,而每个bean的创建又使用了单例模式。

补充知识点：
引申Q：log4j与slf4j的日志级别控制？logback的区别？

SLF4J其实只是一个门面服务而已，他并不是真正的日志框架，真正的日志的输出相关的实现还是要依赖Log4j、logback等日志框架的。
由于SLF4J比较常用，这里多用一些篇幅，再来简单分析一下SLF4J，主要和Log4J做一下对比。
相比较于Log4J的API，SLF4J有以下几点优势：

Log4j 提供 TRACE, DEBUG, INFO, WARN, ERROR 及 FATAL 六种纪录等级，
但是 SLF4J 认为 ERROR 与 FATAL 并没有实质上的差别，所以拿掉了 FATAL 等级，只剩下其他五种。
大部分人在程序里面会去写logger.error(exception),其实这个时候Log4j会去把这个exception.tostring
真正的写法应该是logger(message.exception); 而SLF4J就不会使得程序员犯这个错误。
Log4j间接的在鼓励程序员使用string相加的写法（这种写法是有性能问题的），而SLF4J就不会有这个问题 ,你可以使用logger.error(“{} is+serviceid”,serviceid);
使用SLF4J可以方便的使用其提供的各种集体的实现的jar。（类似commons-logger）
从commons–logger和Log4j 合并非常方便，SLF4J也提供了一个swing的tools来帮助大家完成这个合并。SLF4J 只支持 MDC，不支持 NDC。提供字串内容替换的功能，会比较有效率，说明如下：
// 传统的字符串产生方式，如果没有要记录Debug等级的信息，就会浪费时间在产生不必要的信息上