【Java开发】设计模式 01:单例模式

1 单例模式介绍

单例模式(Singleton Pattern)是Java中最为基础的设计模式。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。

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

1.1 场景

  • 目的:控制实例数目,节省系统资源;

  • 适用:若一个全局使用的类频繁地创建与销毁,单例模式可以证一个类仅有一个实例,并提供一个访问它的全局访问点。

  1. 要求生产唯一序列号;

  1. WEB 中的计数器,不用每次刷新都在数据库里加一次,用单例先缓存起来;

  1. 创建的一个对象需要消耗的资源过多,比如 I/O 与数据库的连接等。

  • 优点:

  1. 如此内存中只有一个实例,减少了内存的开销;

  1. 避免对资源的多重占用(比如写文件操作)。

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

注:spring boot项目中将该对象注入到bean,那么该对象就默认为单例,这时也可以使用@Scope去设定单例和原型以及其他模式。

1.2基础实现方式

以下是基础的实现方式,创建一个 Singleton 类,存在私有构造函数和本身的一个静态实例。

Singleton 类提供了一个静态方法,供外界获取它的静态实例。Client,我们的演示类使用 Singleton 类来获取 Singleton 对象。

📌 1.创建Singleton单例类

public class Singleton {

    //让构造函数为 private,这样该类就不会被实例化
    private Singleton(){}

    //创建 SingleObject 的一个对象
    private static Singleton INSTANCE = new Singleton();

    //获取唯一可用的对象
    public static Singleton getInstance(){
        return INSTANCE;
    }

}

📌 2.从singleton类获取唯一的对象。

public class Client {
    public static void main(String[] args) {
        //不合法的构造函数--因为SingleObject()私有,不可见
//        Singleton singleton = new Singleton();

        Singleton singleton1 = Singleton.getInstance();
        Singleton singleton2 = Singleton.getInstance();

        System.out.println(singleton1);
        System.out.println(singleton2);
    }
}

控制台输出:

2 实现方式汇总

类型

Lazy 初始化

多线程安全

实现难度

懒汉式--线程不安全

容易

懒汉式--线程安全

容易

饿汉式

容易

双重校验锁

较复杂

双重校验锁+volatile

较复杂

静态内部类

一般

枚举

容易

ThreadLocal

较复杂

CAS锁

较复杂

2.1 懒汉式--线程不安全

这种方式是最基本的实现方式,最大的问题是不支持多线程,因为没有加锁 synchronized,所以严格意义上它并不算单例模式。

public class Lazyman1 {

    private static Lazyman1 instance;

    private Lazyman1(){}

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

接下来介绍的几种实现方式都支持多线程,但是在性能上有所差异。

2.2 懒汉式--线程安全

这种方式能够在多线程中很好的工作,但是效率低。

优点:第一次调用才初始化,避免内存浪费。

缺点:必须加锁 synchronized 才能保证单例,但加锁会影响效率。

public class Lazyman2 {

    private static Lazyman2 instance;

    private Lazyman2(){}

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

2.3 饿汉式

这种方式比较常用,但容易产生垃圾对象。它基于类加载机制避免了多线程的同步问题,因为类加载过程JVM会自动加锁,因此保证了单例特性。

优点:没有加锁,执行效率会提高。

缺点:类加载时就初始化,浪费内存。

public class Hungry {

    private Hungry(){}

    private final static Hungry HUNGRY = new Hungry();

    public static Hungry getInstance(){
        return HUNGRY;
    }
}

2.4 双重校验锁(DCL,即 double-checked locking)

这种方式采用双锁机制,安全且在多线程情况下能保持高性能。

不过DCL还是可能会出现指令重排的问题~

public class DLC {

    private static DLC instance;

    private DLC(){}

    public static DLC getInstance() {
        if (instance==null){
            synchronized (LazyMan.class){
                if (instance==null){
                    instance = new DLC();//不是一个原子性操作
                    /*
                     * 1.分配内存空间
                     * 2.执行构造方法,初始化对象
                     * 3.把这个对象指向这个空间
                     *
                     * 可能:
                     * 123
                     * 132 若多线程,A到达3,B会认为lazyMan非空,但是lazyMan此时还没有完成构造,那么就会有问题
                     */
                }
            }
        }
        return instance;
    }
}

2.5 双重校验锁+volatile

用于处理DCL可能出现的问题(指令重排)

解决方案:只需要给instance的声明加上volatile关键字(volatile--静止指令重排),对它的写操作就会有一个内存屏障。

public class DLCVolatile {

    private static volatile DLCVolatile instance;

    private DLCVolatile(){}

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

2.6 静态内部类

也称为登记类,这种方式能达到双检锁方式一样的功效,但实现更简单。对静态域使用延迟初始化,应使用这种方式而不是双检锁方式。这种方式只适用于静态域的情况,双检锁方式可在实例域需要延迟初始化时使用。

这种方式也利用了类加载机制保证初始化instance时只有一个线程,他和饿汉式不同在于:饿汉式只要单例类被加载,那么instance就会被实例化;而静态内部类类加载后,instance不一定被初始化,因为InnerClass类没有被主动使用,只有显示通过调用getInstance方法时,才会显示装载InnerClass类,从而实例化instance。

//静态内部类
public class Holder {
    private Holder(){}

    public static Holder getInstance(){
        return InnerClass.INSTANCE ;
    }

    public static class InnerClass{
        private static final Holder INSTANCE  = new Holder();
    }
}

2.7 枚举

实现单例模式的最佳方法,简洁,自动支持序列化机制,防止多次实例化。

这种方式是 Effective Java 作者 Josh Bloch 提倡的方式,它不仅能避免多线程同步问题,而且还自动支持序列化机制,防止反序列化重新创建新的对象,绝对防止多次实例化。不过,由于 JDK1.5 之后才加入 enum 特性,在实际工作中很少用。

📌 实现方式

public enum EnumSignle {

    INSTANCE;

    public EnumSignle getInstance(){
        return INSTANCE;
    }
}

class Test{
    public static void main(String[] args) {
        EnumSignle enumSignle1 = EnumSignle.INSTANCE;
        EnumSignle enumSignle2 = EnumSignle.INSTANCE;
        System.out.println(enumSignle1);
        System.out.println(enumSignle2);
    }
}

控制台输出:

📌 通过枚举将已有类改造为单例类

public class Singleton {
    private Singleton(){}
    
    public static enum EnumSignle1 {
        INSTANCE;
        
        private Singleton instance = null;
        
        private EnumSignle1(){
            instance = new Singleton();
        }
        
        public Singleton getInstance(){
            return instance;
        }
    }
}

class Test1{
    public static void main(String[] args) {
        Singleton singleton1 = Singleton.EnumSignle1.INSTANCE.getInstance();
        Singleton singleton2 = Singleton.EnumSignle1.INSTANCE.getInstance();
        System.out.println(singleton1 ==singleton2);
    }
}

2.8 ThreadLocal--线程安全

ThreadLocal会为每一个线程提供一个独立的变量副本,从而隔离了多个线程对数据的访问冲突。对于多线程资源共享的问题,同步机制采用了“以时间换空间”的方式,而ThreadLocal采用了“以空间换时间”的方式。前者仅提供一份变量,让不同的线程排队访问,而后者为每一个线程都提供了一份变量,因此可以同时访问而互不影响。

public class TLSingleton {

    private static final ThreadLocal<TLSingleton> tlSingleton = new ThreadLocal<TLSingleton>(){
        @Override
        protected TLSingleton initialValue() {
            return new TLSingleton();
        }
    };
    
    private TLSingleton(){}

    public static TLSingleton getInstance() {
        return tlSingleton.get();
    }
}

2.9 CAS锁实现(线程安全)

public class CASSingleton {

    private CASSingleton(){}

    private static final AtomicReference<CASSingleton> INSTANCE = new AtomicReference<CASSingleton>();

    public static CASSingleton getInstance() {
        for (; ; ) {
            CASSingleton current = INSTANCE.get();

            if (current != null) {
                return current;
            }

            current = new CASSingleton();

            if (INSTANCE.compareAndSet(null, current)) {
                return current;
            }
        }
    }
}

📌 总结

一般情况下,不建议使用第1种和第2种懒汉方式,建议使用第3种饿汉方式。只有在要明确实现lazy loading效果时,才会使用第6种静态内部类方式。如果涉及到反序列化创建对象时,可以尝试使用第7种枚举方式。如果有其他特殊的需求,可以考虑使用第4种双检锁方式。

  • 1
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

尹煜

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值