Java23种设计模式之单例模式
单例模式
- 前言
- 一、单例模式特点
-
- 二、单例模式的优点
- 三、单例模式的缺点
- 四、饿汉式单例模式
- 五、懒汉式单例模式
- 总结
前言
单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一，也是一种很常见的设计模式。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。
一、单例模式特点
下面我们来一张比较有意思的图说明：
这样单例模式保证一个类只有一个实例，减少了内存开销，尤其是那种频繁的创建和摧毁的场景，避免了对资源的多重占用，比如文件IO操作。
二、单例模式的优点
1、在内存里只有一个实例，减少了内存开销，尤其是那种频繁的创建和摧毁的场景。
2、避免对资源的多重占用，比如文件操作。
三、单例模式的缺点
1、没有接口，不能被继承，违背了单一职责设计原则，一个类应该只关心其内部业务逻辑，而不关心外部怎么实例化。
2、 该模式在多线程环境下需要进行特殊处理， 避免多个线程多次创建单例对象。
3、单例的客户端代码单元测试可能会比较困难， 因为许多测试框架以基于继承的方式创建模拟对象。 由于单例类的构造函数是私有的， 而且绝大部分语言无法重写静态方法， 所以你需要想出仔细考虑模拟单例的方法。 要么干脆不编写测试代码， 或者不使用单例模式。
四、饿汉式单例模式
首先创建单例模式类，私有化构造方法，一来就创建一个单例对象，表示很饥饿。
/**
* @description: 单列模式
* @author: dt
* @date: 2021/4/5 12:16
* @version: v1.0
*/
public class Hungry {
/**
* 让构造函数为 private，这样该类就不会被实例化
*/
private Hungry() {
}
/**
* 创造一个静态单例对象
*/
private final static Hungry HUNGRY = new Hungry();
/**
* 获取唯一可用的对象
* @return
*/
public static Hungry getInstance(){
return HUNGRY;
}
public void showMessage(){
System.out.println("Hello World!");
}
}
获取单例对象实例：
public static void main(String[] args) {
// 不可用被实例化,编译直接报错
// Hungry hungry = new Hungry();
// 获取唯一可用对象
Hungry hungry = Hungry.getInstance();
hungry.showMessage();
}
但是这样的饿汉式模式是有问题的，会产生什么问题呢？
假设这里有四组资源，是非常耗内存的，浪费空间，我们应该在使用的时候再去加载，于是乎就有了懒汉式单列模式。
/**
* @description: 单列模式
* @author: dt
* @date: 2021/4/5 12:16
* @version: v1.0
*/
public class Hungry {
/**
* 假设这里有四组资源，是非常耗内存的，浪费空间，我们应该在使用的时候再去加载
*/
private byte[] data1 = new byte[1024*1024];
private byte[] data2 = new byte[1024*1024];
private byte[] data3 = new byte[1024*1024];
private byte[] data4 = new byte[1024*1024];
/**
* 让构造函数为 private，这样该类就不会被实例化
*/
private Hungry() {
}
/**
* 创造一个单例对象
*/
private final static Hungry HUNGRY = new Hungry();
/**
* 获取唯一可用的对象
* @return
*/
public static Hungry getInstance(){
return HUNGRY;
}
public void showMessage(){
System.out.println("Hello World!");
}
}
五、懒汉式单例模式
/**
* @description: 懒汉式单列模式
* @author: ydf
* @date: 2021/4/12 21:47
* @version: v1.0
*/
public class LazyMan {
private LazyMan(){
System.out.println(Thread.currentThread().getName());
}
public static LazyMan lazyMan;
public static LazyMan getInstance(){
// 不为null，我们才使用实例对象
if(lazyMan==null){
lazyMan = new LazyMan();
}
return lazyMan;
}
// 单线程下单列模式可以运行的，完全没问题，如果并发条件下就有问题了
// 测试并发条件
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
new Thread(()->{
LazyMan.getInstance();
}).start();
}
}
}
打印结果：
单线程下单列模式可以运行的，完全没问题，如果并发条件下就有问题了。那么怎么解决呢？
加锁控制：双重检测锁模式
/**
* @description: 懒汉式单列模式
* @author: ydf
* @date: 2021/4/12 21:47
* @version: v1.0
*/
public class LazyMan {
private LazyMan(){
System.out.println(Thread.currentThread().getName());
}
private volatile static LazyMan lazyMan;
public static LazyMan getInstance(){
// 加锁，双重检测一下
if(lazyMan == null){
synchronized (LazyMan.class){
if(lazyMan == null){
lazyMan = new LazyMan();
}
}
}
return lazyMan;
}
// 单线程下单列市客运的，如果并发条件下就有问题了
// 测试并发条件
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
new Thread(()->{
LazyMan.getInstance();
}).start();
}
}
}
通过观察我们可以看到通过双重检测锁，保证了线程对象的唯一，测试成功。
总结
1、执行效率上：饿汉式没有加任何的锁，因此执行效率比较高。懒汉式一般使用都会加同步锁，效率比饿汉式差。
2、性能上：饿汉式在类加载的时候就初始化，不管你是否使用，它都实例化了，所以会占据空间，浪费内存。懒汉式什么时候需要什么时候实例化，相对来说不浪费内存。
3、饿汉式： 在类加载时就初始化创建单例对象，线程安全，但不管是否使用都创建对象可能会浪费内存。
4、懒汉式： 在外部调用时才会加载，线程不安全，可以加锁保证线程安全但效率低。