设计模式——单例模式

最新推荐文章于 2022-10-04 22:00:17 发布

Yawn__

最新推荐文章于 2022-10-04 22:00:17 发布

阅读量337

点赞数 1

分类专栏：设计模式

本文链接：https://blog.csdn.net/ly0724ok/article/details/116654859

版权

设计模式专栏收录该内容

9 篇文章 0 订阅

订阅专栏

1.什么是单例

单例 Singleton 是设计模式的一种，其特点是只提供唯一一个类的实例,具有全局变量的特点，在任何位置都可以通过接口获取到那个唯一实例; 具体运用场景如：

设备管理器，系统中可能有多个设备，但是只有一个设备管理器，用于管理设备驱动;
数据池，用来缓存数据的数据结构，需要在一处写，多处读取或者多处写，多处读取;

意图：保证一个类仅有一个实例，并提供一个访问它的全局访问点。简单来说使用单例模式可以带来下面几个好处：

对于频繁使用的对象，可以省略创建对象所花费的时间，这对于那些重量级对象而言，是非常可观的一笔系统开销；
由于 new 操作的次数减少，因而对系统内存的使用频率也会降低，这将减轻 GC 压力，缩短 GC 停顿时间。

2. 单例模式的实现

一个类能返回对象一个引用(永远是同一个)和一个获得该实例的静态方法，通常使用getInstance。当getInstance被调用时，如果类持有的引用不为空就返回这个引用，如果类保持的引用为空就创建该类的实例并将实例的引用赋予该类保持的引用。

同时我们还将该类的构造函数定义为私有方法，这样其他处的代码就无法通过调用该类的构造函数来实例化该类的对象，只有通过该类提供的静态方法来得到该类的唯一实例。

需要注意的地方：
单例模式在多线程的场合下须小心使用，如果当唯一实例尚未创建时，有两个线程同时调用创建方法，那么它们同时没有检测到唯一实例的存在，从而同时各自创建了一个实例，这样就有两个实例被构造出来，从而违反了单例模式中实例唯一的原则。

解决这个问题的办法是为指示类是否已经实例化的变量提供一个互斥锁(虽然这样会降低效率)。

实现单利模式的原则和过程：

单例模式：确保一个类只有一个实例，自行实例化并向系统提供这个实例
单例模式分类：饿单例模式（类加载时实例化一个对象给自己的引用），懒单例模式（调用取得实例的方法如getInstance时才会实例化对象）（java中饿单例模式性能优于懒单例模式，c++中一般使用懒单例模式）
单例模式要素：
- a.私有构造方法
- b.私有静态引用指向自己实例
- c.以自己实例为返回值的公有静态方法

3.单例模式的优缺点

优点：

提供了对唯一实例的受控访问。在单例模式中，活动的单例只有一个实例，对单例类的所有实例化得到的都是相同的一个实例
由于在系统内存中只存在一个对象，因此可以节约系统资源，当需要频繁创建和销毁的对象时单例模式无疑可以提高系统的性能
避免对共享资源的多重占用

缺点：

不适用于变化的对象，如果同一类型的对象总是要在不同的用例场景发生变化，单例就会引起数据的错误，不能保存彼此的状态
由于单利模式中没有抽象层，因此单例类的扩展有很大的困难。
单例类的职责过重，在一定程度上违背了“单一职责原则”。
单例使用过多会造成一些问题：
1.为了节省资源将数据库连接池对象设计为的单例类，可能会导致共享连接池对象的程序过多而出现连接池溢出；
2.如果实例化的对象长时间不被利用，系统会认为是垃圾而被回收，这将导致对象状态的丢失。

4. 举个例子

一般采用饿汉式，若对资源十分在意可以采用静态内部类，不建议采用懒汉式及双重检测

4.1 饿汉式：

单例实例在类装载时就构建，急切初始化。（预先加载法）
优点 :
1.线程安全
2.在类加载的同时已经创建好一个静态对象，调用时反应速度快

缺点 :
资源效率不高，可能getInstance()永远不会执行到，但执行该类的其他静态方法或者加载了该类（class.forName)，那么这个实例仍然初始化

//饿汉式
public class Singleton{
	private Singleton(){
	}
	public static Singleton instance = new Singleton();
	public Singleton getInstance{
		return instance;
	}
}

4.2 懒汉式：

单例实例在第一次被使用时构建，延迟初始化。
优点：
避免了饿汉式的那种在没有用到的情况下创建事例，资源利用率高，不执行getInstance()就不会被实例，可以执行该类的其他静态方法。

缺点：
懒汉式在单个线程中没有问题，但多个线程同事访问的时候就可能同时创建多个实例，而且这多个实例不是同一个对象，虽然后面创建的实例会覆盖先创建的实例，但是还是会存在拿到不同对象的情况。解决这个问题的办法就是加锁synchonized，第一次加载时不够快，多线程使用不必要的同步开销大。

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

4.3 双重检测：

优点
资源利用率高，不执行getInstance()就不被实例，可以执行该类其他静态方法

缺点
第一次加载时反应不快，由于java内存模型一些原因偶尔失败

原理：
双层校验, 第一次校验不是线程安全的，也就是说可能有多个线程同时得到singleton为null的结果，接下来的同步代码块保证了同一时间只有一个线程进入，而第一个进入的线程会创建对象，等其他线程再进入时对象已创建就不会继续创建。这是一个很巧妙的方式，如果对整个方法同步，所有获取单例的线程都要排队，但实际上只需要对创建过程同步来保证"单例"，多个线程不管是否已经有单例可以同时去请求。

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

4.4 静态内部类

优点
资源利用率高，不执行getInstance()不被实例，可以执行该类其他静态方法

缺点
第一次加载时反应不够快

class Singleton{
	private Singleton(){
	}
	//静态内部类
	public static class SingletonHelp{
		static Singleton instance = new Singleton();
	}
	public static Singleton  getInstance(){
		return SingletonHelp.instance();
	}
}

原理：

静态内部类的优点：

外部类加载时并不需要立即加载内部类，内部类不被加载则不去初始化INSTANCE，故而不占内存。
即当SingleTon第一次被加载时，并不需要去加载SingleTonHoler，只有当getInstance()方法第一次被调用时，才会去初始化INSTANCE,第一次调用getInstance()方法会导致虚拟机加载SingleTonHoler类，这种方法不仅能确保线程安全，也能保证单例的唯一性，同时也延迟了单例的实例化。

那么，静态内部类又是如何实现线程安全的呢？首先，我们先了解下类的加载时机。

类加载时机：JAVA虚拟机在有且仅有的5种场景下会对类进行初始化。

1.遇到new、getstatic、setstatic或者invokestatic这4个字节码指令时，对应的java代码场景为：new一个关键字或者一个实例化对象时、读取或设置一个静态字段时(final修饰、已在编译期把结果放入常量池的除外)、调用一个类的静态方法时。
2.使用java.lang.reflect包的方法对类进行反射调用的时候，如果类没进行初始化，需要先调用其初始化方法进行初始化。
3.当初始化一个类时，如果其父类还未进行初始化，会先触发其父类的初始化。
4.当虚拟机启动时，用户需要指定一个要执行的主类(包含main()方法的类)，虚拟机会先初始化这个类。
5.当使用JDK 1.7等动态语言支持时，如果一个java.lang.invoke.MethodHandle实例最后的解析结果REF_getStatic、REF_putStatic、REF_invokeStatic的方法句柄，并且这个方法句柄所对应的类没有进行过初始化，则需要先触发其初始化。

再回头看下getInstance()方法，

调用的是SingleTonHoler.INSTANCE，取的是SingleTonHoler里的INSTANCE对象，跟上面那个（双重检测）DCL方法不同的是，getInstance()方法并没有多次去new对象，故不管多少个线程去调用getInstance()方法，取的都是同一个INSTANCE对象，而不用去重新创建。
当getInstance()方法被调用时，SingleTonHoler才在SingleTon的运行时常量池里，把符号引用替换为直接引用，这时静态对象INSTANCE也真正被创建，然后再被getInstance()方法返回出去，这点同饿汉模式。那么INSTANCE在创建过程中又是如何保证线程安全的呢？在《深入理解JAVA虚拟机》中，有这么一句话:
- 虚拟机会保证一个类的()方法在多线程环境中被正确地加锁、同步，如果多个线程同时去初始化一个类，那么只会有一个线程去执行这个类的()方法，其他线程都需要阻塞等待，直到活动线程执行()方法完毕。如果在一个类的()方法中有耗时很长的操作，就可能造成多个进程阻塞(需要注意的是，其他线程虽然会被阻塞，但如果执行()方法后，其他线程唤醒之后不会再次进入()方法。同一个加载器下，一个类型只会初始化一次。)，在实际应用中，这种阻塞往往是很隐蔽的。

故而，可以看出INSTANCE在创建过程中是线程安全的，所以说静态内部类形式的单例可保证线程安全，也能保证单例的唯一性，同时也延迟了单例的实例化。

其实静态内部类也有着一个致命的缺点？

传参问题，由于是静态内部类的形式去创建单例的，故外部无法传递参数进去，例如Context这种参数，所以，我们创建单例时，可以在静态内部类与DCL模式里自己斟酌。

4.5 枚举单例

Java中的枚举和其它语言不同，它是一个对象。早期的 Java 是没有枚举类型的大家都用类似于单例的方式来实现枚举，简单的说就是让构造 private 化，在 static 块中产生多个 final 的对象实例，通过比较引用（或 equals）来进行比较，这种模式跟单例模式相似，不能由使用者产生实例，但是有多个实例
早期用类的方式实现的枚举

public class MyEnum {
    public static MyEnum NumberZero;
    public static MyEnum NumberOne;
    public static MyEnum NumberTwo;
    public static MyEnum NumberThree;

    static {
        NumberZero = new MyEnum(0);
        NumberOne = new MyEnum(1);
        NumberTwo = new MyEnum(2);
        NumberThree = new MyEnum(3);
    }

    private final int value;

    private MyEnum(int value) {
        this.value = value;
    }

    public int getValue() {
        return value;
    }
}

从 Java 5 开始有枚举类型之后，类似的实现可以这样

类似类方式实现的枚举实现

public enum MyEnum {
    NumberZero(0),
    NumberOne(1),
    NumberTwo(2),
    NumberThree(3);

    private final int value;

    MyEnum(int value) {
        this.value = value;
    }

    public int getValue() {
        return value;
    }
}

其实仔细比较会发现，就是简化了定义过程，构造方法简不能使用 public 或 protected 修饰符，如果省略也不是 package，而是 private；另外 final static 属性定义简化了，static 块也简化掉了。

上面说了，早期就是通过类似单例模式的方式来实现的枚举。而后的枚举实例也和类方式实现极为相似，那么，如果枚举值只有 1 个的时候，其实例也就只有 1 个，就完全符合了单例模式的限定。由于 Java 的 enum 可以跟类一样任意定义方法和属性，所以就完全可以用枚举来实现单例。这是其它语言如 C++、C# 做不到的。

枚举单例：

public enum  EnumSingleton {
    INSTANCE;
    public EnumSingleton getInstance(){
        return INSTANCE;
    }
}

验证一下：

public static void main(String[] args) throws Exception{
        EnumSingleton singleton1=EnumSingleton.INSTANCE;
        EnumSingleton singleton2=EnumSingleton.INSTANCE;
        System.out.println("正常情况下，实例化两个实例是否相同："+(singleton1==singleton2));
        Constructor<EnumSingleton> constructor= null;
        constructor = EnumSingleton.class.getDeclaredConstructor();
        constructor.setAccessible(true);
        EnumSingleton singleton3= null;
        singleton3 = constructor.newInstance();
        System.out.println(singleton1+"\n"+singleton2+"\n"+singleton3);
        System.out.println("通过反射攻击单例模式情况下，实例化两个实例是否相同："+(singleton1==singleton3));
    }

结果会报Exception in thread “main” java.lang.NoSuchMethodException。
出现这个异常的原因是因为EnumSingleton.class.getDeclaredConstructors()获取所有构造器，会发现并没有我们所设置的无参构造器，只有一个参数为（String.class,int.class）构造器，而且在反射在通过newInstance创建对象时，会检查该类是否ENUM修饰，如果是则抛出异常，反射失败。所以枚举是不怕反射攻击的。

newInstance方法源码：

public T newInstance(Object ... initargs)
        throws InstantiationException, IllegalAccessException,
               IllegalArgumentException, InvocationTargetException
    {
        if (!override) {
            if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
                Class<?> caller = Reflection.getCallerClass();
                checkAccess(caller, clazz, null, modifiers);
            }
        }
        
        //反射在通过newInstance创建对象时，会检查该类是否ENUM修饰，如果是则抛出异常
        if ((clazz.getModifiers() & Modifier.ENUM) != 0)
            throw new IllegalArgumentException("Cannot reflectively create enum objects");
        ConstructorAccessor ca = constructorAccessor;   // read volatile
        if (ca == null) {
            ca = acquireConstructorAccessor();
        }
        @SuppressWarnings("unchecked")
        T inst = (T) ca.newInstance(initargs);
        return inst;
    }

Yawn__

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
设计模式——单例模式

1.什么的单例单例 Singleton 是设计模式的一种，其特点是只提供唯一一个类的实例,具有全局变量的特点，在任何位置都可以通过接口获取到那个唯一实例; 具体运用场景如：设备管理器，系统中可能有多个设备，但是只有一个设备管理器，用于管理设备驱动;数据池，用来缓存数据的数据结构，需要在一处写，多处读取或者多处写，多处读取;意图：保证一个类仅有一个实例，并提供一个访问它的全局访问点。简单来说使用单例模式可以带来下面几个好处：对于频繁使用的对象，可以省略创建对象所花费的时间，这对于那些重量级对
复制链接

扫一扫