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

1、说明

1.1 定义

单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

1.2 特点

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

1.3 优点

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

1.4 缺点

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

1.5 应用场景

1. 要求生产唯一序列号。
2. WEB 中的计数器，不用每次刷新都在数据库里加一次，用单例先缓存起来。
3. 创建的一个对象需要消耗的资源过多，比如 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();
  }
}

3.3 执行结果

单例模式,获取唯一可用的对象(可多次获取,但只有一个对象)

验证是否一个对象

调用公共方法

参考资料:​​​设计模式​​​、​​JAVA设计模式之单例模式​​，感谢作者的无私奉献~