浅谈设计模式

最新推荐文章于 2024-09-21 09:47:19 发布

gray_dog3

最新推荐文章于 2024-09-21 09:47:19 发布

阅读量357

点赞数 1

分类专栏：设计模式文章标签：设计模式单例模式

本文链接：https://blog.csdn.net/lishuangling21/article/details/70767490

版权

设计模式专栏收录该内容

1 篇文章 0 订阅

订阅专栏

存在目的

节约资源确保系统中某个类只有一个实例。（确保对象的唯一性，避免不必要的系统开销）

单例模式的三个要点

由三个要点可知单例模式的结构特点：

内部实现只生成一个实例
提供静态的 getInstance() 工厂方法，让客户可以访问它的唯一实例
构造函数设为私有，在单例类内部定义一个静态 Singleton 类型对象，作为外界使用的唯一实例

基本 UML 图：

单例模式实现方式

饿汉式

public class EagerSingleton {
    
    private final static EagerSingleton instance = new EagerSingleton();

    private EagerSingleton() {
    }

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

类加载时静态变量 instance 会被初始化，此时私有构造方法被调用，单例唯一实例被创建，可确保实例的唯一性,但是类加载时需要创建实例，可能会导致加载时间变长。

懒汉式

public class LazySingleton {

    private  static LazySingleton instance = null;

    private LazySingleton() {
    }

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

这是最简单的懒汉式，只有用到的时候才去判断有没有实例，但是这样 getInstance() 并不能在多线程时保证只创建出一个实例,可以修改为：

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

因为判空和 new 对象的操作并不是原子操作，所以依然不能保证原自性，也就也可能，A、B 线程先后访问 instance 为 null，A 在 new 对象，而 B 在等锁，然后 B 又去 new 了一个实例。同样不能保证原子性。

把整个 getInstance() 方法加锁来保证原子性的话，作为一个单例被各种其他类访问的第一步都是在 getInstance(),这样会在多线程的时候影响执行效率，所以又有了下面这种：

public class LazySingleton {

    private static volatile LazySingleton instance = null;

    private LazySingleton() {
    }

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

这样貌似就完美的解决了执行效率和实例唯一性的问题。但是需要注意到的一点是：必须在 instance 前面加修饰符 volatile 来确保多线程正确处理。

volatile 只有在 JDK 1.5 以及以上的版本才能正确执行。volatile 会屏蔽一些 Java 虚拟机的优化，而影响执行效率。可见上面这种双重判断锁定也不是一种完美的单例解决方案。

静态内部类实现单例（完美方案）

public class Singleton {
    private Singleton() {
    }

    public static Singleton getInstance() {

        return HolderClass.instance;
    }

    private static class HolderClass{
        private final static Singleton instance = new Singleton();
    }
}

这种方式实现了延时加载，保证了线程的安全性，又不影响系统性能。