搜 索

创建型模式丨单例模式

  • 229阅读
  • 2021年09月05日
  • 0评论
首页 / 默认分类 / 正文

前言

单例模式(Singleton Pattern),属于创建型模式的一种,我觉得它是 23 种设计模式中最容易理解的模式。

定义与特点

定义:指一个类只有一个实例,且该类能自行创建这个实例的一种模式。
特点:

  • 单例类只能有一个实例对象;
  • 该单例对象必须由单例类自行创建;
  • 单例类对外只提供一个访问它的全局访问点;
  • 单例类隐藏所有的构造方法。

编码实现

通常,普通类的构造函数是公有的,外部类可以通过“new 构造函数()”来生成多个实例。但是,如果将类的构造函数设为私有的,外部类就无法调用该构造函数,也就无法生成多个实例。这时该类自身必须定义一个静态私有实例,并向外提供一个静态的公有函数用于创建或获取该静态私有实例。

常见的实现单例模式的方法有:饿汉式、懒汉式、双重锁定、静态内部类、枚举和使用 ThreadLocal。

饿汉式

public class Singleton {
    private static Singleton instance = new Singleton();

    private Singleton() {
    }

    public static Singleton getInstance() {
        return instance;
    }
}

饿汉式,就是类一旦加载,不管需要不需要,就把单例初始化完成,保证使用 getInstance()的时候,单例是已经存在的了。

虽然是线程安全的,可以直接用于多线程而不会出现问题;但是类加载时就初始化,浪费内存,而且容易产生垃圾对象。

懒汉式

public class Singleton {
    private static Singleton instance = null;

    private Singleton() {
    }

    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

懒汉式,先声明只一个初始值为 null 的 instance 遍历,只有当需要使用 getInstance()的时候,判断变量是否已经被初始化,没有初始化才 new 一个实例。

虽然按需加载,避免了内存浪费,减少了类初始化时间;但是它是非线程安全的,必须使用关键字 synchronized 同步才能保证单例,而加锁又会影响效率。

双重锁定

为了解决懒汉式加锁影响效率这个问题,双重检查锁定出现了。

public class Singleton {
    private static Singleton instance = null;

    private Singleton() {
    }

    public static Singleton getInstance() {
        // 第一次检查
        if (instance == null) {
            synchronized (Singleton.class) {
                // 第二次检查
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

此时为了减少锁的判断量,只需要对单例进行判断即可,如果不为空直接返回,如果为空,那就创建新的单例对象。
虽然对单重锁效率提升不少,但是比较耗时耗内存。

但是,这种写法依然不够稳妥。
JVM 底层为了优化程序运行效率,可能对上段代码进行指令重排序,在一些特殊情况下可能会出现 instance 遍历并没有完全完成初始化。为了防止这种情况,给 instance 变量加上 volatile 关键字。
volatile 关键字有两个作用:被它修饰的变量保证对所有线程可见;禁止指令重排序优化。

public class Singleton {
    // 禁止指令重排序优化
    private static volatile Singleton instance = null;

    private Singleton() {
    }

    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

静态内部类

除了双检锁方式外,还有一种比较常见的静态内部类方式保证懒汉式单例的线程安全:

public class Singleton {
    private static class SingletonHolder {
        public static final Singleton INSTANCE = new Singleton();
    }

    private Singleton() {
    }

    public static final Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

这种写法可以达到双重锁定一样的效果,而且避免了 synchronized 带来的性能影响;这种实现方法既保证了线程安全,又能做到延迟加载。

枚举

public enum Singleton {
    INSTANCE;

    // 枚举同普通类一样,可以有自己的成员变量和方法
    public void doSomething() {
        System.out.println("推荐使用枚举实现单例");
    }
}

这是实现单例模式的最佳方法。代码更简洁,线程安全,支持序列化机制,可防止反序列化和反射的破坏。

使用 ThreadLocal

这种实现是线程单例,不是全局单例。也就是说,在一个线程只存在一个单例对象,不同的线程有不同的单例对象。

import java.util.HashMap;
import java.util.Map;

public class AppContext {
    private static final ThreadLocal<AppContext> local = new ThreadLocal<>();

    private Map<String, Object> data = new HashMap<>();

    public Map<String, Object> getData() {
        return getAppContext().data;
    }

    //批量存数据
    public void setData(Map<String, Object> data) {
        getAppContext().data.putAll(data);
    }

    //存数据
    public void set(String key, String value) {
        getAppContext().data.put(key, value);
    }

    //取数据
    public void get(String key) {
        getAppContext().data.get(key);
    }

    //初始化的实现方法
    private static AppContext init() {
        AppContext context = new AppContext();
        local.set(context);
        return context;
    }

    //做延迟初始化
    public static AppContext getAppContext() {
        AppContext context = local.get();
        if (null == context) {
            context = init();
        }
        return context;
    }

    //删除实例
    public static void remove() {
        local.remove();
    }
}

现在绝大多数单例模式的实现基本上都是采用的 ThreadLocal 这一种实现方式。

单例模式的替代方案

在不需要维持任何状态下,仅仅⽤于全局访问,那么使⽤静态类的⽅式更加⽅便。

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

public class Singleton {
    public static Map<String, String> cache = new ConcurrentHashMap<>();
}

优点与缺点

优点:

  • 可以保证内存里只有一个实例,减少了内存的开销。
  • 对有限资源的合理利用,保护有限的资源,防止资源重复竞抢。
  • 具备全局唯一访问点的权限控制,方便按照统一规则管控权限。

缺点:

  • 不支持有参数的构造函数。
  • 一般没有接口,扩展困难。
  • 耦合性高,因为隐蔽了不同对象之间的调用关系。

应用场景

  • 在计算机系统中,Windows 的回收站、资源管理器、系统中的缓存等常常被设计成单例。
  • 在 Spring 框架中,Bean 默认情况下就是单例模式。
  • 保存一些全局性的属性设置。
  • 某些类创建实例时占用资源较多,或实例化耗时较长,且经常使用。

注意:某类需要频繁实例化,而创建的对象又频繁被销毁,例如多线程的线程池、网络连接池、数据库连接池等,这种不是单例设计模式,而是【池化技术】。
参考:知乎

参考

C语言中文网
CSDN
趣学设计模式 — 黄靖锋
打 赏
  • 支付宝
  • 微信
Alipay
WeChatPay
评论区
暂无评论
avatar