23种设计模式一:单例模式

Posted 2023-02-28

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了23种设计模式一:单例模式相关的知识，希望对你有一定的参考价值。

1、说明

1.1 定义

单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

1.2 特点

构造函数是私有的。
单例类只能有一个实例。
单例类必须自己创建自己的唯一实例。
单例类必须给所有其他对象提供这一实例。

1.3 优点

在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例。
避免对资源的多重占用（比如读写文件操作）。

1.4 缺点

没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。

1.5 应用场景

要求生产唯一序列号。
WEB 中的计数器，不用每次刷新都在数据库里加一次，用单例先缓存起来。
创建的一个对象需要消耗的资源过多，比如 I/O 与数据库的连接等。

2、实现

我们将创建一个SingletonDemo类，它有私有的构造函数和本身的一个静态实例。单例模式的写法有好几种，这里主要介绍饿汉模式、懒汉模式两种。

2.1 饿汉模式(推荐)

是否Lazy初始化：否
是否多线程安全：是
优点：没有加锁，执行效率会提高。
缺点：类加载时就初始化，浪费内存。

/**
 * 单例-饿汉模式
 */
public class SingletonDemo 
  // 创建 SingletonDemo 的一个对象
  private static SingletonDemo singletonDemo = new SingletonDemo();
  
  /**
   * 私有构造方法,让构造函数为private,这样该类就不会被实例化
   */
  private SingletonDemo() 
    super();
  
  
  /**
   * 获取唯一可用对象的静态方法
   * @return 当前类的唯一可用对象
   */
  public static SingletonDemo getSingletonDemo() 
    return singletonDemo;

2.2 懒汉模式

2.2.1 版本一

是否Lazy初始化：是
是否多线程安全：否

/**
 * 单例-懒汉模式,在第一次调用的时候实例化自己
 * 延迟加载，但是线程不安全
 */
public class SingletonDemo 
    // 定义私有对象,先不实例化
    private static SingletonDemo singletonDemo;
    
    /**
     * 构造方法私有化
     */
    private SingletonDemo() 
        super();
    
    
    /**
     * 在对外暴露的方法中实例化对象
     * @return 当前类的唯一可用对象
     */
    public static SingletonDemo getSingletonTest()   
        if (singletonDemo == null)   
            singletonDemo = new SingletonDemo();  
          
        return singletonDemo;

2.2.2 版本二

是否Lazy初始化：是
是否多线程安全：是

/**
 * 单例-懒汉模式,在第一次调用的时候实例化自己
 * 延迟加载,并且线程安全,但是效率不高
 */
public class SingletonDemo 
    // 定义私有对象,先不实例化
    private static SingletonDemo singletonDemo;
    
    /**
     * 构造方法私有化
     */
    private SingletonDemo() 
        super();
    
    
    /**
     * 在对外暴露的方法中实例化对象
     * @return 当前类的唯一可用对象
     */
    public synchronized static SingletonDemo getSingletonTest()   
        if (singletonDemo == null)   
            singletonDemo = new SingletonDemo();  
          
        return singletonDemo;

2.2.3 版本三

是否Lazy初始化：是
是否多线程安全：是

/**
 * 单例-懒汉模式,在第一次调用的时候实例化自己(双重校验锁)
 * 延迟加载,线程安全,效率较高
 */
public class SingletonDemo 
    // 定义私有对象,先不实例化,volatile修饰,禁止指令重拍,为了后续线程安全
    private volatile static SingletonDemo singletonDemo;
    
    /**
     * 构造方法私有化
     */
    private SingletonDemo() 
        super();
    
    
    /**
     * 在对外暴露的方法中实例化对象(双重校验锁)
     * @return 当前类的唯一可用对象
     */
    public static SingletonDemo getSingletonTest()   
        if (singletonDemo == null) 
            synchronized (SingletonDemo.class) 
                if (singletonDemo == null) 
                    singletonDemo = new SingletonDemo(); 
                
            
          
        return singletonDemo;

3、示例

这里我们使用饿汉模式来创建一个示例

3.1 创建单例类

/**
 * 单例-饿汉模式
 */
public class SingletonDemo 
  // 创建 SingletonDemo 的一个私有实例, 类初始化即加载
  private static SingletonDemo singletonDemo = new SingletonDemo();
  
  /**
   * 构造方法私有化
   */
  private SingletonDemo() 
    super();
    System.out.println("11111111111");

  
  
  /**
   * 类的唯一出口,获取唯一可用对象的静态方法
   * @return 当前类的唯一可用对象
   */
  public static SingletonDemo getSingletonDemo() 
    return singletonDemo;
  
  
  /**
   * 公共方法
   */
  public void sayHello() 
    System.out.println("你好,世界!");

3.2 调用单例类

/**
 * 单例调用
 */
public class SingletonDemoTest 
  public static void main(String[] args) 
    // 单例模式,获取唯一可用的对象(可多次获取,但只有一个对象)
    SingletonDemo st01 =SingletonDemo.getSingletonDemo();
    SingletonDemo st02 =SingletonDemo.getSingletonDemo();

    // 验证是否一个对象
    if (st01.equals(st02)) 
      System.out.println("是一个对象!");
     else 
      System.out.println("不是一个对象!");
    
    
    // 调用公共方法
    st01.sayHello();