设计模式之“单例模式”

最新推荐文章于 2024-11-02 22:15:00 发布

csdnszr

最新推荐文章于 2024-11-02 22:15:00 发布

阅读量178

点赞数

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

本文链接：https://blog.csdn.net/szr4630/article/details/84586408

版权

设计模式专栏收录该内容

1 篇文章 0 订阅

订阅专栏

单例模式（Singleton）

什么是单例模式

单例对象（Singleton）是一种常用的设计模式。在Java应用中，单例对象能保证在一个JVM中该对象只有一个实例存在。这里主要介绍三种：懒汉式单例、饿汉式单例、登记式单例。

这样的模式有几个好处：

某些类创建比较频繁，对于一些大型的对象，这是一笔很大的系统开销；
省去了new操作符，降低了系统内存的使用频率，减轻GC（Garbage Collection）压力；
有些类如交易所的核心交易引擎，控制着交易流程，如果该类可以创建多个的话，系统完全乱了。（比如一个军队出现了多个司令员同时指挥，肯定会乱成一团），所以只有使用单例模式，才能保证核心交易服务器独立控制整个流程。

单例模式有以下特点：

单例类只能有一个实例；
单例类必须自己创建自己的唯一实例，即自行实例化；
单例类必须给所有其他对象提供这一实例。

在计算机系统中，线程池、缓存、日志对象、对话框、打印机、显卡的驱动程序对象常被设计成单例。这些应用都或多或少具有资源管理器的功能。每台计算机可以有若干个打印机，但只能有一个Printer Spooler，以避免两个打印作业同时输出到打印机中。每台计算机可以有若干通信端口，系统应当集中管理这些通信端口，以避免一个通信端口同时被两个请求同时调用。总之，选择单例模式就是为了避免不一致状态。

在讲单例之前，要对Java类加载器加载内容的顺序进行一下说明：

从上往下加载（Java的变量需要先声明才能使用）
先静态后动态（对象实例化，静态块和static关键字修饰在实例化以前分配内存空间）
先属性后方法（成员变量不能定义在方法中，只能定义在class下）

懒汉式单例

首先我们写一个简单的单例类（懒汉模式）：

public class Singleton1 {

	/** 
	 * 持有私有静态实例，防止被引用，此处赋值为null，目的是实现延迟加载 
	 * 如果在这里就创建对象，在类中不管用户是否要使用该类的对象，就会先创建好了一个实例放在内存中
	 */
	private static Singleton1 instance = null;

	/* 私有构造方法，防止被实例化 */
	private Singleton1() {
	}

	/* 静态工程方法，创建实例 */
	public static Singleton1 getInstance() {
		if (instance == null) {
			instance = new Singleton1();
		}
		return instance;
	}

	/* 如果该对象被用于序列化，可以保证对象在序列化前后保持一致 */
	public Object readResolve() {
		return instance;
    }
    /** 
     * 当把Singleton1对象(通过getInstance方法获得的那个单例对象)序列化后再从内存中读出时, 
     * 就有一个全新的跟原来一样的Singleton1对象存在了。这就要用到readResolve方法来维护单例模式。
     */
}

Singleton1通过将构造方法限定为private避免了类在外部被实例化，在同一个虚拟机范围内，Singleton1的唯一实例只能通过getInstance()方法访问。但是以上懒汉式单例的实现没有考虑线程安全问题，它是线程不安全的，并发环境下很可能出现多个Singleton1 实例，要实现线程安全，有以下三种方式，都是对getInstance这个方法改造，保证了懒汉式单例的线程安全。

我们首先会想到对getInstance方法加synchronized关键字，如下：

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

但是，synchronized关键字锁住的是这个对象，这样的用法，在性能上会有所下降，因为每次调用getInstance()，都要对对象上锁，事实上只有在第一次创建对象的时候需要加锁，之后就不需要了，所以这个地方需要改进。我们改成下面的“双重检查锁定”：

//为了保证多线程环境下的另一种实现方式，双重锁检查
public static Singleton3 getInstance() {
	if (instance == null) {
		synchronized (Singleton3.class) {  //用类对象来作为锁
			if (instance == null) {
				instance = new Singleton3();
			}
	    }
	}
	return instance;
}

似乎解决了之前提到的问题，将synchronized关键字加在了内部，也就是说当调用的时候是不需要加锁的，只有在instance为null，并创建对象的时候才需要加锁，性能有一定的提升。

但是这样的情况还是有可能有问题的，看下面的情况：在Java指令中，创建对象和赋值操作是分开进行的，也就是说instance = new Singleton();语句是分两步执行的。但是JVM并不保证这两个操作的先后顺序，也就是说有可能JVM会为新的Singleton实例分配空间，然后直接赋值给instance成员，然后再去初始化这个Singleton实例。这样就可能出错了。

我们以A、B两个线程为例：

A、B线程同时进入了第一个if判断
A首先进入synchronized块，由于instance为null，所以它执行instance = new Singleton();
由于JVM内部的优化机制，JVM先画出了一些分配给Singleton实例的空白内存，并赋值给instance成员（注意此时JVM没有开始初始化这个实例），然后A离开了synchronized块。
B进入synchronized块，由于instance此时不是null，因此它马上离开了synchronized块并将结果返回给调用该方法的程序。
此时B线程打算使用Singleton实例，却发现它没有被初始化，于是错误发生了。

在Java指令中创建对象和赋值操作是分开进行的，也就是说instance = new Singleton();语句并非是一个原子操作，在 JVM 中这句代码大概做了下面 3 件事情:

给new的对象分配内存；
调用Singleton的构造函数来初始化成员变量；
将引用instance指向分配的内存空间（执行完这步 instance 就为非 null 了）

但是在 JVM 的即时编译器中存在指令重排序的优化。也就是说上面的第二步和第三步的顺序是不能保证的，最终的执行顺序可能是 1-2-3 也可能是 1-3-2。如果是后者，则在 3 执行完毕、2 未执行之前，另外一个线程B抢夺到了CPU的执行权,这时instance已经是非null了（但却没有初始化），所以线程B会直接返回 instance，然后使用，结果就会出现问题了(因为对象还没有初始化)。所以程序还是有可能发生错误，其实程序在运行过程是很复杂的，从这点我们就可以看出，尤其是在写多线程环境下的程序更有难度，有挑战性。

实际情况是，单例模式使用内部类来维护单例的实现，JVM内部的机制能够保证当一个类被加载的时候，这个类的加载过程是线程互斥的。这样当我们第一次调用getInstance的时候，JVM能够帮我们保证instance只被创建一次，并且会保证把赋值给instance的内存初始化完毕，这样我们就不用担心上面的问题。同时该方法也只会在第一次调用的时候使用互斥机制，这样就解决了低性能问题。这样我们暂时总结一个完美的单例模式：

public class Singleton4 {

	/* 私有构造方法，防止被实例化 */
	private Singleton4() {
	}

	/* 此处使用一个静态内部类来维护单例 */
	private static class SingletonFactory {
		private static final Singleton4 INSTANCE = new Singleton4();
	}

	/* 获取实例 */
	public static final Singleton4 getInstance() {
		return SingletonFactory.INSTANCE;
	}

	/* 如果该对象被用于序列化，可以保证对象在序列化前后保持一致 */
	public Object readResolve() {
		return getInstance();
	}
}

这种方式是Singleton4 类被装载了，instance不一定被初始化。因为SingletonFactory 类没有被主动使用，只有显示通过调用getInstance方法时，才会显示装载SingletonFactory 类，从而实例化instance。想象一下，如果实例化instance很消耗资源，我想让他延迟加载，另外一方面，我不希望在Singleton4 类加载时就实例化，因为我不能确保Singleton4 类还可能在其他的地方被主动使用从而被加载，那么这个时候实例化instance显然是不合适的。这个时候，这种比上面1、2都好一些，既实现了线程安全，又避免了同步带来的性能影响。

但是如果在构造函数中抛出异常，实例将永远得不到创建，也会出错。所以说，十分完美的东西是没有的，我们只能根据实际情况，选择最适合自己应用场景的实现方法。也有人这样实现：因为我们只需要在创建类的时候进行同步，所以只要将创建和getInstance()分开，单独为创建加synchronized关键字，也是可以的。考虑性能的话，整个程序只需创建一次实例，所以性能也不会有什么影响：

public class SingletonTest {

	private static SingletonTest instance = null;

	private SingletonTest() {
	}

	private static synchronized void syncInit() {
		if (instance == null) {
			instance = new SingletonTest();
		}
	}

	public static SingletonTest getInstance() {
		if (instance == null) {
			syncInit();
		}
		return instance;
	}
}

补充：采用"影子实例"的办法为单例对象的属性同步更新

public class SingletonTest {

	private static SingletonTest instance = null;
	private Vector properties = null;

	public Vector getProperties() {
		return properties;
	}

	private SingletonTest() {
	}

	private static synchronized void syncInit() {
		if (instance == null) {
			instance = new SingletonTest();
		}
	}

	public static SingletonTest getInstance() {
		if (instance == null) {
			syncInit();
		}
		return instance;
	}

	public void updateProperties() {
		SingletonTest shadow = new SingletonTest();
		properties = shadow.getProperties();
	}
}

饿汉式单例

//饿汉式单例类.在类初始化时，已经自行实例化 
public class Singleton5 {

    //同样也是将默认构造方法私有化
    private Singleton5() {
    }
    
    //声明静态变量，在类实例化之前就初始化变量,将对象引用保存
    public static final Singleton5 INSTANCE = new Singleton5();
    
    //开放静态方法，获取实例
    public static Singleton5 getInstance(){
        return INSTANCE;
    }
}

饿汉式在类创建的同时就已经创建好一个静态的对象供系统使用，以后不再改变，所以天生是线程安全的。

枚举式单例

public enum Singleton6{

    INSTANCE;
    
    public void getInstance(){
    }
}

这种方式不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象，可谓是很坚强的壁垒啊，不过在实际工作中，我很少看见有人这么写过。

登记式单例

//类似Spring里面的方法，将类名注册，下次从里面直接获取。
public class Singleton7{

    private static Map<String,Singleton7> instance = new HashMap<String,Singleton7>();
    
    static{
        Singleton7 single = new Singleton7();
        instance.put(single.getClass().getName(),single);
    }
    
    //保护的默认构造
    protected Singleton7(){
    }
    
    //静态工厂方法，返还此类唯一的实例
    public static Singleton7 getInstance(String name){
    
        if(name == null){
            name = Singleton7.class.getName();
        }
        
        if(instance.get(name) == null){
            try {  
                instance.put(name,(Singleton7)Class.forName(name).newInstance());
            } catch (InstantiationException e) {  
                e.printStackTrace();  
            } catch (IllegalAccessException e) {  
                e.printStackTrace();  
            } catch (ClassNotFoundException e) {  
                e.printStackTrace();  
            }  
        }
        
        return instance.get(name);
    }
}

登记式单例实际上维护了一组单例类的实例，将这些实例存放在一个Map（登记薄）中，对于已经登记过的实例，则从Map直接返回，对于没有登记的，则先登记，然后返回。

这里我对登记式单例标记了可忽略，我的理解来说，首先它用的比较少，另外其实内部实现还是用的饿汉式单例，因为其中的static方法块，它的单例在类被装载的时候就被实例化了。

懒汉式单例跟饿汉式单例的根本区别

饿汉就是类一旦加载，就把单例初始化完成，保证getInstance的时候，单例是已经存在的了。而懒汉比较懒，只有当调用getInstance的时候，才回去初始化这个单例。另外从以下两点再区分以下这两种方式：

1、线程安全：

饿汉式天生就是线程安全的，可以直接用于多线程而不会出现问题，
懒汉式本身是非线程安全的，为了实现线程安全有几种写法，分别是上面的1、2、3，这三种实现在资源加载和性能方面有些区别。

2、资源加载和性能：

饿汉式在类创建的同时就实例化一个静态对象出来，不管之后会不会使用这个单例，都会占据一定的内存，但是相应的，在第一次调用时速度也会更快，因为其资源已经初始化完成。

而懒汉式顾名思义，会延迟加载，在第一次使用该单例的时候才会实例化对象出来，第一次调用时要做初始化，如果要做的工作比较多，性能上会有些延迟，之后就和饿汉式一样了。

至于1、2、3这三种实现又有些区别，
第1种，在方法调用上加了同步，虽然线程安全了，但是每次都要同步，会影响性能，毕竟99%的情况下是不需要同步的；
第2种，在getInstance中做了两次null检查，确保了只有第一次调用单例的时候才会做同步，这样也是线程安全的，同时避免了每次都同步的性能损耗；
第3种，利用了classloader的机制来保证初始化instance时只有一个线程，所以也是线程安全的，同时没有性能损耗，所以一般我倾向于使用这一种。

通过单例模式的学习告诉我们：

1、单例模式理解起来简单，但是具体实现起来还是有一定的难度。

2、synchronized关键字锁定的是对象，在用的时候，一定要在恰当的地方使用（注意需要使用锁的对象和过程，可能有的时候并不是整个对象及整个过程都需要锁）。