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设计模式之单例模式​​，感谢作者的无私奉献~