第12篇单例模式

最新推荐文章于 2025-08-27 20:18:21 发布

原创最新推荐文章于 2025-08-27 20:18:21 发布 · 248 阅读

0 ·

CC 4.0 BY-SA版权

设计模式专栏收录该内容

12 篇文章

订阅专栏

本文深入解析单例模式的概念，探讨其在软件设计中的应用。详细介绍了饿汉式和懒汉式的区别，以及如何在不同场景下实现线程安全的单例模式。包括静态常量、静态代码块、线程安全的懒汉式、双重检查锁定、静态内部类和枚举等8种实现方式。

一、概念

单例模式(Singleton Pattern)：确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例，这个类称为单例类，它提供全局访问的方法。单例模式是一种对象创建型模式。
单例模式有三个要点：一是某个类只能有一个实例；二是它必须自行创建这个实例；三是它必须自行向整个系统提供这个实例
单例通常又分为两种模式：

饿汉式：在加载的时候就创建出来，着急创建出来。
懒汉式：需要使用的时候再创建出来，比较懒

二、结构图

在这里插入图片描述

饿汉式结构图
在这里插入图片描述
懒汉式结构图

三、核心代码

单例模式的写法有八种：饿汉式(静态常量)、饿汉式(静态代码块)、懒汉式(线程不安全)、懒汉式(线程安全，同步方法) 、懒汉式(线程安全，同步代码块) 、双重锁检查、静态内部类、枚举

饿汉式(静态常量)

package com.firewolf.javabase.pattern.s004_sp;

/**
 * 饿汉模式（静态常量）
 */
public class EH_staticconstant {

  private static final EH_staticconstant instance = new EH_staticconstant();

  private EH_staticconstant() {
  }

  public static EH_staticconstant getInstance() {
    return instance;
  }

}

优点：
这种写法比较简单，就是在类装载的时候就完成实例化。避免了线程同步问题
缺点：
在类装载的时候就完成实例化，没有达到LazyLoading的效果。如果从始至终从未使用过这个实例，则会造成内存的浪费

饿汉式(静态代码块)
```
package com.firewolf.javabase.pattern.s004_sp;

/**
 * 饿汉式，静态代码块
 */
public class EH_staticcode {

  private static EH_staticcode instance = null;

  static {
    instance = new EH_staticcode();
  }

  private EH_staticcode() {

  }

  public static EH_staticcode getInstance() {
    return instance;
  }
}
```
优点：
这种写法比较简单，就是在类装载的时候就完成实例化。避免了线程同步问题
缺点：
在类装载的时候就完成实例化，没有达到LazyLoading的效果。如果从始至终从未使用过这个实例，则会造成内存的浪费
这种方式其实和上面的类似，只不过是采用了不同的方法进行初始化。
懒汉式(线程不安全)
```
package com.firewolf.javabase.pattern.s004_sp;

public class LH_NoSafe {

  private static LH_NoSafe instance = null;

  private LH_NoSafe() {
  }

  public static LH_NoSafe getInstance() {
    if (instance == null) {
      instance = new LH_NoSafe();
    }
    return instance;
  }
}
```
优点：
起到了LazyLoading的效果，但是只能在单线程下使用
缺点：
如果在多线程下，一个线程进入了if(singleton==null)判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。所以在多线程环境下不可使用这种方式。

懒汉式(线程安全，同步方法)

package com.firewolf.javabase.pattern.s004_sp;

/**
 * 懒汉式，线程安全，同步方法
 */
public class LH_Safe_SyncMethod {

  private static LH_Safe_SyncMethod instance = null;

  private LH_Safe_SyncMethod() {
  }

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

优点：
解决了线程安全问题
缺点：
效率太低了，每个线程在想获得类的实例时候，执行getInstance()方法都要进行同步。而其实这个方法只执行一次实例化代码就够了，后面的想获得该类实例，直接 return 就行了。方法进行同步效率太低。

懒汉式(线程安全，同步代码块)

package com.firewolf.javabase.pattern.s004_sp;

/**
 * 懒汉式，线程安全，同步代码
 */
public class LH_Safe_SyncCode {

  private static LH_Safe_SyncCode instance = null;

  private LH_Safe_SyncCode() {
  }

  public static synchronized LH_Safe_SyncCode getInstance() {
    if (instance == null) {
      synchronized ("lock") {
        instance = new LH_Safe_SyncCode();
      }
    }
    return instance;
  }
}

延迟了加锁的时间。

双重检查

package com.firewolf.javabase.pattern.s004_sp;

/**
 * 双重检查
 */
public class DoubleCheck {

  private static volatile DoubleCheck instance;

  private DoubleCheck() {
  }

  public static synchronized DoubleCheck getInstance() {
    if (instance == null) {
      synchronized ("lock") {
        if (instance == null) {
          instance = new DoubleCheck();
        }
      }
    }
    return instance;
  }
}

静态内部类
```
package com.firewolf.javabase.pattern.s004_sp;

public class StaticInnerClass {	
  private StaticInnerClass(){};
  public static  StaticInnerClass getInstance() {
    return InnerClass.INSTANCE;
  }

  private static class InnerClass {
    private static final StaticInnerClass INSTANCE = new StaticInnerClass();
  }
}
```
优点：
这种方式采用了类装载的机制来保证初始化实例时只有一个线程。
静态内部类方式在Singleton类被装载时并不会立即实例化，而是在需要实例化时，调用getInstance方法，才会装载 SingletonInstance 类，从而完成 Singleton 的实例化。达到了懒加载的效果；
类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的。
总之：避免了线程不安全，利用静态内部类特点实现延迟加载，效率高

枚举

package com.firewolf.javabase.pattern.s004_sp;

/**
 * 枚举方式
 */
public enum Enum {
  INSTANCE;

  public void sayHello() {
    System.out.println("hello");
  }
}

优点：这借助JDK1.5中添加的枚举来实现单例模式。不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象。