返回 导航

其他

hangge.com

Java - GoF设计模式详解5（单例模式）

作者：hangge | 2023-03-10 08:30

五、单例模式

1，基本介绍

（1）使用单例模式（Singleton）能确保一个类只有一个实例，并且提供了对该类的全局访问入口，它可以确保使用这个类实例的所有的对象使用相同的实例。

（2）单例模式的常见写法有懒汉模式、饿汉模式、静态内部类、双重校验锁、枚举等，各种方式推荐的使用场景如下：
  • 如果不要求延迟加载（Lazy Loading）则建议使用“饿汉模式”。
  • 如果明确要实现延迟加载（Lazy Loading）效果则建议使用“静态内部类”方式。
  • 如果涉及到反序列化创建对象时，可以尝试使用“枚举”方式。
  • 如果有其他特殊的需求，可以考虑使用“双重校验锁”方式。
  • 无论何种情况，都不推荐使用“懒汉模式”
注意：除了懒汉模式根据获取对象方法是否加锁（synchronized）可以分为线程安全和线程不安全两种情况，其他的单例模式写法都是线程安全的。

2，懒汉模式

（1）懒汉模式很简单，即定义一个私有的静态对象 instance，之所以定义 instance 为静态，是因为静态属性或方法是属于类的，能够很好地保障单例对象的唯一性。然后定义一个静态方法获取该对象，如果该对象为 null，则定义一个对象实例并将其赋值给 instance，这样下次再获取该对象时便能够直接获取了。因为没有加锁 synchronized，在多线程不能正常工作，所以严格意义上它并不算单例模式。
优点：第一次调用才初始化，避免内存浪费。
缺点：这种方式线程不安全，在多线程下不能正常工作。 
public class Singleton {
  private static Singleton instance;
  private Singleton (){}
  public static Singleton getInstance() {
    if (instance == null) {
      instance = new Singleton();
    }
    return instance;
  }
}

（2）为了确保线程安全，则需要对获取对象方法加锁（synchronized）。
优点：第一次调用才初始化，避免内存浪费。
缺点：必须加锁 synchronized 才能保证单例，但加锁会影响效率。
public class Singleton {
  private static Singleton instance;
  private Singleton (){}
  public static synchronized Singleton getInstance() {
    if (instance == null) {
      instance = new Singleton();
    }
    return instance;
  }
}

3，饿汉模式

（1）饿汉模式指在类中直接定义全局的静态对象的实例并初始化，然后提供一个方法获取该实例对象。它与懒汉模式区别在于：
  • 懒汉模式第一次调用时，单例对象一定为空， 然后去实例化对象并赋值，这样下次就能直接获取对象了。
  • 饿汉模式是在定义单例对象的同时将 其实例化的，直接使用便可。即在 Class Loader 完成后该类的实例便已经存在于 JVM 中了。
优点：没有加锁，执行效率会提高。
缺点：类加载时就初始化，浪费内存。

（2）下面是饿汉模式样例代码： 
public class Singleton {
  private static Singleton instance = new Singleton();
  private Singleton (){}
  public static Singleton getInstance() {
    return instance;
  }
}

4，双重校验锁

（1）双锁模式指在懒汉模式的基础上做进一步优化，给静态对象的定义加上 volatile 锁来保障初始化时对象的唯一性，在获取对象时通过 synchronized (Singleton.class）给单例类加锁来保障操作的唯一性。
优点：第一次调用才初始化，避免内存浪费。并且执行效率比懒汉模式高（getInstance() 的性能对应用程序很关键）。

（2）下面是双重校验锁样例代码： 
public class Singleton {
  private volatile static Singleton singleton;
  private Singleton (){}
  public static Singleton getInstance() {
    if (singleton == null) {
      synchronized (Singleton.class) {
        if (singleton == null) {
          singleton = new Singleton();
        }
      }
    }
    return singleton;
  }
}

5，静态内部类（登记式）

（1）这种方式能达到双检锁方式一样的功效，但实现更简单。简单来说就是通过在类中定义一个静态内部类，将对象实例的定义和初始化放在内部类中完成， 我们在获取对象时要通过静态内部类调用其单例对象。之所以这样设计，是因为类的静态内部类在 JVM 中是唯一的，这很好地保障了单例对象的唯一性。
优点：第一次调用才初始化，避免内存浪费。并且执行效率高。实现又比双重校验锁简单。

（2）下面是静态内部类样例代码：
提示： 这种方式 Singleton 类被装载了，instance 不一定被初始化。因为 SingletonHolder 类没有被主动使用，只有通过显式调用 getInstance 方法时，才会显式装载 SingletonHolder 类，从而实例化 instance。
public class Singleton {
  private static class SingletonHolder {
    private static final Singleton INSTANCE = new Singleton();
  }
  private Singleton (){}
  public static final Singleton getInstance() {
    return SingletonHolder.INSTANCE;
  }
}

6，枚举

（1）这种方式是 Effective Java 作者 Josh Bloch 提倡的方式，它更加简洁，不但自动支持序列化机制，而且能绝对防止多次实例化。
优点：执行效率高。自动支持序列化机制。实现简单。
缺点：类加载时就初始化，浪费内存。

（2）下面是使用枚举实现单例模式样例： 
public enum Singleton {
  INSTANCE;

  private int value;

  private Singleton() {
    value = 1;
  }
  public int getValue() {
    return value;
  }

  public void setValue(int value) {
    this.value = value;
  }

  public void increase() {
    this.value++;
  }
}

（3）测试一下： 
public class Test {
  public static void main(String[] args) {
    System.out.println(Singleton.INSTANCE.getValue());
    Singleton.INSTANCE.setValue(2);
    Singleton.INSTANCE.increase();
    System.out.println(Singleton.INSTANCE.getValue());
  }
}

附一：JDK 中的单例模式

1，java.lang.Runtime

（1）java.lang.Runtime 类是一个单例类，它提供了对当前运行时环境的访问。运行时环境提供了很多有用的方法，如获取可用处理器数量、可用内存数量、执行外部命令等等。
（2）下面是一个要获取当前可用处理器数量样例：
int processors = Runtime.getRuntime().availableProcessors();

2,java.awt.Desktop

（1）java.awt.Desktop 类提供了对当前桌面环境的访问。这个类提供了方法来执行桌面操作，如打开文件、编辑文件、打开浏览器等等。
（2）下面是一个打开一个文件样例：
File file = new File("example.txt");
Desktop.getDesktop().open(file);

3，java.util.logging.Logger

（1）java.util.logging.Logger 是 JDK 日志记录工具的日志对象，它可以将应用程序的日志记录到指定的文件或控制台中。通过 Logger 类的两个静态 getLogger() 方法来取得实例，name 是 Logger 的名称，当名称相同时候，同一个名称的 Logger 只创建一个（即每一个 Logger 都是单例的）。
// 查找或创建一个logger
static Logger getLogger(String name) 
      
// 为指定子系统查找或创建一个logger  
static Logger getLogger(String name, String resourceBundleName)

（2）下面是一个使用日志对象记录一条日志信息样例： 
Logger logger = Logger.getLogger("com.example");
logger.info("Hello, Logger!");

附二：Spring 中的单例模式

（1）Spring 中无论使用注解，还是 xml 配置的 bean，如果没有指定 scope 属性，则默认使用单例模式。
（2）Spring MVC 中的 Controller 也是 Bean，默认也是单例的。
评论

全部评论（0）

回到顶部