设计模式-创建型模式之单例设计模式

一、设计 模式

设计模式（De sig n pattern）代表了最佳的实践，通常被有经验的面向对象的软件开发人员所采用。设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。

设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了重用代码、让代码更容易被他人理解、保证代码可靠性。毫无疑问，设计模式于己于他人于系统都是多赢的，设计模式使代码编制真正工程化，设计模式是软件工程的基石，如同大厦的一块块砖石一样。项目中合理地运用设计模式可以完美地解决很多问题，每种模式在现实中都有相应的原理来与之对应，每种模式都描述了一个在我们周围不断重复发生的问题，以及该问题的核心解决方案，这也是设计模式能被广泛应用的原因。

二、设计模式的六大原则

开闭原则（Ope n Clos e Pr inc iple）
开闭原则的意思是：对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码，实现一个热插拔的效果。简言之，是为了使程序的扩展性好，易于维护和升级。想要达到这样的效果，我们需要使用接口和抽象类，后面的具体设计中我们会提到这点。
里氏代换原则（Li sk ov Subs ti tut ion Pr inc iple）
里氏代换原则是面向对象设计的基本原则之一。里氏代换原则中说，任何基类可以出现的地方，子类一定可以出现。LSP 是继承复用的基石，只有当派生类可以替换掉基类，且软件单位的功能不受到影响时，基类才能真正被复用，而派生类也能够在基类的基础上增加新的行为。里氏代换原则是对开闭原则的补充。实现开闭原则的关键步骤就是抽象化，而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范。
依赖倒转原则（De p end e n ce In version Pr inc iple）
这个原则是开闭原则的基础，具体内容：针对接口编程，依赖于抽象而不依赖于具体。
接口隔离原则（In ter face Seg reg a t ion Pr inc iple）
这个原则的意思是：使用多个隔离的接口，比使用单个接口要好。它还有另外一个意思是：降低类之间的耦合度。由此可见，其实设计模式就是从大型软件架构出发、便于升级和维护的软件设计思想，它强调降低依赖，降低耦合。
迪米特法则，又称最少知道原则（Demeter Princ iple）
最少知道原则是指：一个实体应当尽量少地与其他实体之间发生相互作用，使得系统功能模块相对独立。
合成复用原则（Co mp o site Reuse Princ iple）
合成复用原则是指：尽量使用合成/聚合的方式，而不是使用继承。

三、设计模式分类

设计模式常见的有23类，分为创建型、结构型、行为型。

创建型模式主要用于创建对象，为设计类实例化对象做指导。
结构型主要处理类或对象之间的组合，为如何设计类以形成更大的结构做指导。
行为型主要描述类或对象的交互和职责的分类，为类的交互和职责分类做指导。

四、单例设计模式

单例模式（Singlet on Pat tern）是 Java 中最简单的设计模式之一。它提供了一种创建对象的最佳方式。

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

单例的实现方式也有多种，包括：饿汉式、懒汉式、静态内部方式、枚举单例、双重检测锁方式。

懒汉式

类初始化时，不会初始化该对象，真正需要使用的时候才会创建该对象，具备懒加载功能。
在设计单例时，首先需要私有化无参构造函数，避免使用 new 创建对象。

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

这种情况如果并发获取对象的时候，因为加了synchronized 锁，会抢夺锁导致一些性能的下降。

饿汉式

类初始化时，会立即加载该对象，线程天生安全，调用效率高，这种方式比较常用，但容易产生垃圾对象。
它基于 classloader 机制避免了多线程的同步问题，不过，instance 在类装载时就实例化，虽然导致类装载的原因有很多种，在单例模式中大多数都是调用 getInstance() 方法，但是也不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化 instance 显然没有达到 lazy loading 的效果。

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

这种方式在加载时就创建好了对象，相对于上面的懒汉式，性能会更高。但是对于一些不常用的类，在一开始就加载好，浪费内存，容易产生垃圾对象。

双检锁/双重校验锁 DCL

上面可以看出，使用懒汉式由于在方法上加了synchronized 会导致请求排队，使用饿汉式，又会有可能造成浪费内存产生垃圾对象，带着问题来看下双重校验锁机制。

public class Singleton {  
    private volatile static Singleton singleton;  
    private Singleton (){}  
    public static Singleton getSingleton() {  
    if (singleton == null) {  
        synchronized (Singleton.class) {  
	        if (singleton == null) {  
	            singleton = new Singleton();  
	        }  
        }  
    }  
    return singleton;  
    }  
}

这种形式，在获取对象时先判断有无实例，有的话就直接返回，相对于懒汉式消除了锁争夺等待。如果没有被实例化，就使用synchronized 锁住当前对象，那么，都锁住了为什么在里面还要再判断一次是否有实例呢，这是因为假如并发有两个线程获取对象，都判断为null，那下面就会争夺锁，抢到锁的就可以安心的实例化对象了，当创建好释放锁后，另一个线程走下去再创建对象不就创建重复了嘛，上一个线程已经创建好了呀，所以在这里再判断一次，就是为了在刚开始创建对象的时候防止并发重复实例化对象。解决了懒汉式和饿汉式的弊端。

静态内部类

上面双重校验锁机制似乎就已经很好了，但还有没有办法解决懒汉式和饿汉式的弊端呢，那就是静态内部类；
这种方式能达到双检锁方式一样的功效，但实现更简单。对静态域使用延迟初始化，应使用这种方式而不是双检锁方式。这种方式只适用于静态域的情况，双检锁方式可在实例域需要延迟初始化时使用。

public class Singleton {  

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

优势：解决懒汉式和饿汉式的弊端
劣势：需要两个类去做到这一点，虽然不会创建静态内部类的对象，但是其 Clas s 对象还是会被创建，而且是属于永久带的对象。

枚举

这种实现方式还没有被广泛采用，但这是实现单例模式的最佳方法，因为枚举本身是单例的。它更简洁，自动支持序列化机制，绝对防止多次实例化。
这种方式不仅能避免多线程同步问题，而且还自动支持序列化机制，防止反序列化重新创建新的对象，绝对防止多次实例化。不过，由于 JDK1.5 之后才加入 enum 特性，用这种方式写不免让人感觉生疏，在实际工作中，也很少用。

public enum Singleton {  
    INSTANCE;  
    public void whateverMethod() {  
    }  
}

public class Singleton {
	public static Singleton getInstance() {
		return SingletonEnum.INSTANCE.getInstance();
	}

	private static enum SingletonEnum{
		INSTANCE;
		private Singleton instance;

		private SingletonEnum() {
			instance= new Singleton ();
		}
		
		public Singleton getInstance() {
			return instance;
		}
	}