设计模式之单例模式

出来深圳已接近一年了，总想着用文笔来记录一下自己成长的轨迹，所以就开博客了，目的只有三点：1，巩固自己的基础知识2，希望能写出好的文章来让各位没了解过设计模式的coder能对设计模式有个较为深刻的认识。3希望各位专家给出宝贵的意见，互相探讨。

1 设计模式的来源

  从大学课程我们了解到设计模式这个概念是来源于Christopher Alexander所著作的建筑工程书籍，而后被引进到软件工程，想了解历史的同学可以深入了解

2 什么是设计模式

设计模式

设计模式所要达到的目标主要是让code具有复用性并可维护。在现在的企业或者我们用的比较成熟的框架都用到很多种设计模式，如果理解了设计模式相对的再去理解框架都会容易的多。

3 单例模式

单例模式作为一种目标明确、结构简单、理解容易的设计模式，在软件开发中使用频率相当高，在很多应用软件和框架中都得以广泛应用。主要分恶汉式、懒汉式和IoDH模式，我们所熟悉的win版系统的系资源管理器和回收站都是单例模式的应用
1.主要优点
单例模式的主要优点如下：
(1) 单例模式提供了对唯一实例的受控访问。因为单例类封装了它的唯一实例，所以它可以严格控制客户怎样以及何时访问它。
(2) 由于在系统内存中只存在一个对象，因此可以节约系统资源，对于一些需要频繁创建和销毁的对象单例模式无疑可以提高系统的性能。
(3) 允许可变数目的实例。基于单例模式我们可以进行扩展，使用与单例控制相似的方法来获得指定个数的对象实例，既节省系统资源，又解决了单例单例对象共享过多损性能的问题。
2.主要缺点
单例模式的主要缺点如下：
(1) 由于单例模式中没抽象层，因此单例类的扩展很大的困难。
(2) 单例类的职责过重，在一定程度上违背了“单一职责原则”。因为单例类既充当了工厂角色，提供了工厂方法，同时又充当了产品角色，包含一些业务方法，将产品的创建和产品的本身的功能融合到一起。
(3) 现在很多面向对象语言(如Java、C#)的运行环境都提供了自动垃圾回收的技术，因此，如果实例化的共享对象长时间不被利用，系统会认为它是垃圾，会自动销毁并回收资源，下次利用时又将重新实例化，这将导致共享的单例对象状态的丢失。
3.适用场景
在以下情况下可以考虑使用单例模式：
(1) 系统只需要一个实例对象，如系统要求提供一个唯一的序列号生成器或资源管理器，或者需要考虑资源消耗太大而只允许创建一个对象。
(2) 客户调用类的单个实例只允许使用一个公共访问点，除了该公共访问点，不能通过其他途径访问该实例。

(3)jdbc的使用

(4)线程池的使用

package com.singleton.www;

@SuppressWarnings("all")
public class SingletonPatternOne {
/**
 * @author 李双
 *<p>饿汉式</p>
 */	
private static final SingletonPatternOne singletonPattern = new SingletonPatternOne();
public SingletonPatternOne getInstance(){
	return singletonPattern;
}
public static void main(String[] args) {
	SingletonPatternOne  singleton = singletonPattern.getInstance();
}
}

当JVM虚拟机在加载这个类的时候就会实例化这个对象，并且在多线程的情况下使用不会出现问题稳定性好，在大多数情况下使用比较靠谱，在应用程序启动

的时候就会永久的分配内存，但是也会消耗系统资源。

package com.singleton.www;
@SuppressWarnings("all")
public class SingletonPatternTwo {
/**
 * @author 李双
 *<p>懒汉式(Double-Check Locking)</p>
 *
 */
private static volatile SingletonPatternTwo  singletonPatternTwo = null;
public  static  synchronized SingletonPatternTwo singleton(){
	 if(singletonPatternTwo == null ){
		 singletonPatternTwo = new SingletonPatternTwo();
	 }
	
	 return singletonPatternTwo;
	 
}
public  static  SingletonPatternTwo singletonPattern(){
	if(singletonPatternTwo == null ){
	synchronized (SingletonPatternTwo.class) {
		 if(singletonPatternTwo == null ){
			 singletonPatternTwo = new SingletonPatternTwo();
		 }
	}
	}
	 return singletonPatternTwo;
	 
}
}

懒汉式：顾名思义就是比较懒了，当此实例为空的时候才会去实例化这个对象，也就是所谓的延时加载了，在第一次创建这个对象的时候会出现性能上的延迟，而后与恶汉式无区别，在多线程高并发的情况下就可能会实例化多个对象，所以需要用到锁机制来保证代码结果无二义性，只生成一个对象，上述代码中
使用了双重锁定技术，同时也使用了同步方法，本人不太建议使用同步方法，在多线程的情况下对系统的性能有较大的影响。

为何要使用双重检查锁定呢？

考虑这样一种情况，就是有两个线程同时到达，即同时调用 getInstance() 方法，
此时由于 singleTon == null ，所以很明显，两个线程都可以通过第一重的 singleTon == null ，
进入第一重 if 语句后，由于存在锁机制，所以会有一个线程进入 lock 语句并进入第二重 singleTon == null ，
而另外的一个线程则会在 lock 语句的外面等待。
而当第一个线程执行完 new  SingleTon（）语句后，便会退出锁定区域，此时，第二个线程便可以进入 lock 语句块，
此时，如果没第二重 singleTon == null 的话，那么第二个线程还是可以调用 new  SingleTon （）语句，
这样第二个线程也会创建一个 SingleTon实例，这样也还是违背了单例模式的初衷的，
所以这里必须要使用双重检查锁定。
细心的朋友一定会发现，如果我去掉第一重 singleton == null ，程序还是可以在多线程下完好的运行的，
考虑在没第一重 singleton == null 的情况下，
当两个线程同时到达，此时，由于 lock 机制的存在，第一个线程会进入 lock 语句块，并且可以顺利执行 new SingleTon（），
当第一个线程退出 lock 语句块时， singleTon 这个静态变量已不为 null 了，所以当第二个线程进入 lock 时，
还是会被第二重 singleton == null 挡在外面，而无法执行 new Singleton（），
所以在没第一重 singleton == null 的情况下，也是可以实现单例模式的？那么为什么需要第一重 singleton == null 呢？
这里就涉及一个性能问题了，因为对于单例模式的话，new SingleTon（）只需要执行一次就 OK 了，
而如果没第一重 singleTon == null 的话，每一次有线程进入 getInstance（）时，均会执行锁定操作来实现线程同步，
这是非常耗费性能的，而如果我加上第一重 singleTon == null 的话，
那么就只在第一次，也就是 singleTton ==null 成立时的情况下执行一次锁定以实现线程同步，
而以后的话，便只要直接返回 Singleton 实例就 OK 了而根本无需再进入 lock 语句块了，这样就可以解决由线程同步带来的性能问题了。

package com.singleton.www;
@SuppressWarnings("all")
public class SingletonPatternIoDH
{
	/**
	 * @author 李双
	 * <p>IoDH(Initiation on Demand Holder)</p>
	 */
    private  SingletonPatternIoDH()
    {
    }
   
    private static class HolderClass
    {
           private  static final SingletonPatternIoDH  instance = new SingletonPatternIoDH();
    }
   
    public static SingletonPatternIoDH getInstance()
    {
           return HolderClass.instance;
    } 
}

IoDH( Initialization Demand Holde)技术完美的解决了线程问题和延时加载问题，在上述代码中我们使用静态内部类，在JVM加载的时候不会初始化内部类的成员变量instance ，而是当我们调用getInstance()方法时才去生成对象。 由 Java 虚拟机来保证其线程安全性，确保该成员变量只能初始化一次。由于 getInstance() 方法没有任何线程锁定，因此其性能不会造成任何影响。因此强烈建议使用这种单例模式，perfect！