设计模式之单例模式

    单例模式如果细分的话至少有8种以上（笔者知道的实现方式大概就有10种左右）的实现方式，这其中有一些实现方式是存在问题的，例如：线程安全问题、原子性问题等。笔者将列举出可行的单例模式的实现方式（存在问题的方式将不在此列举），并分析其中的优缺点。
    以下是笔者的代码，其中饿汉式和懒汉式是以往最经典和常用的方式：
    饿汉式（静态常量）：

/**
 * 饿汉式（静态常量）
 * 优点：这种写法比较简单，在类装载的时候就完成实例化。避免了线程同步问题。
 * 缺点：在类装载的时候就完成实例化，没有达到Lazy Loading的效果。如果从始至终从未
 * 使用过这个实例，则会造成内存的浪费。
 * 
 * @author JsonLiangyoujun
 * **/
public class HungryMan {
	/*初始化实例*/
	private static final HungryMan hungryMan = new HungryMan();
	
    /*对外提供获得实例调用方法*/
    public static HungryMan getHungryMan() {
		return hungryMan;
	}
    
    /*必须私有化构造方法才能达到单例效果*/
    private HungryMan(){};
     
}

    该方式不能实现懒加载、参数化、配置化，简单地说就是不够灵活。但却是一种简单可行的方式，在Java jdk中就有用到该方式实现单例，例如Runtime类。虽然jdk中没有使用final，但达到的效果是相同的，该方式还能用静态代码块实现。代码如下：
    饿汉式（静态代码块）：

 /** 
 * 饿汉式（静态代码块）
 * @author JsonLiangyoujun
 * **/
public class HungryMan {
	
	private static HungryMan hungryMan;
	
	static{
		hungryMan = new HungryMan();
	}
	
	public static HungryMan getHungryMan() {
		return hungryMan;
	}
    
	private HungryMan(){};
     
}

    该方式效果和优缺点同上。

    懒汉式（线程同步）：

/**
 * 懒汉式（线程同步）
 * 优点：这种写法比较简单，达到了Lazy Loading的效果。解决了线程同步问题。
 * 缺点：效率太低了，每个线程在想获得类的实例的时候，执行getLazyMan()方法都要进行同步。
 * 而其实这个方法只执行一次实例化代码就够了，后面的想获得该类实例，直接return就行了。
 * 
 * @author JsonLiangyoujun
 * **/
public class LazyMan {

	private static LazyMan lazyMan;
	
	private LazyMan(){};
	
    public static synchronized LazyMan getLazyMan() {
    	if(lazyMan == null){
    		lazyMan = new LazyMan();
    	}
		return lazyMan;
	} 
}

    该方式达到了实现懒加载、可参数化、可配置化的要求，但是明显的缺点就是效率太低。

    懒汉式（双重检查）：

/**
 * 懒汉式（双重检查）
 * 优点：线程安全；延迟加载；效率较高。
 * 
 * @author JsonLiangyoujun
 * **/
public class LazyManDoubleCheck {

	private static volatile LazyManDoubleCheck lazyMan;
	
	private LazyManDoubleCheck(){};
	
    public static LazyManDoubleCheck getLazyMan() {
    	if(lazyMan == null){
    		lazyMan = new LazyManDoubleCheck();
    		synchronized (LazyManDoubleCheck.class) {
                if (lazyMan == null) {
                	lazyMan = new LazyManDoubleCheck();
                }
            }
    	}
		return lazyMan;
	} 
}

    该方式值得推荐使用，使用该方式需要对线程知识有一定的了解。

    除了饿汉式和懒汉式，下面笔者再提供两种值得推荐的方式。
    静态内部类式：
   

/**
 * 静态内部类式
 * 优点：避免了线程同步问题，延迟加载，效率高。。
 * 
 * @author JsonLiangyoujun
 * **/
public class StaticInnerClass {
	private StaticInnerClass(){}
	
	private static class StaticInnerClassInstance{
		private static final StaticInnerClass staticInnerClass = new StaticInnerClass();
	}
	
	public static  StaticInnerClass getStaticInnerClass(){
		return StaticInnerClassInstance.staticInnerClass;
	}
}

    该方式类似于饿汉式和懒汉式的结合版，既避免了线程同步问题，又支持延迟加载，还提高了效率。

    枚举式
   

/**
 * 枚举式
 * 优点：避免多线程同步问题，而且还能防止反序列化重新创建新的对象。
 * 
 * @author JsonLiangyoujun
 * **/
public enum Singleton {
	 INSTANCE;
	 //public void whateverMethod(){}
}

    该方式简单直接。不过目前使用的频率不高，可能是因为枚举是在JDK1.5之后的新特性的原因，大家还未习惯使用枚举吧。
   
    以上六种方式均为可行的实现单例模式的方式，可根据具体需求进行选择。

    下面列举几个单例模式的应用场景：
    1.应用程序的日志应用，一般都何用单例模式实现，这一般是由于共享的日志文件一直处于打开状态，因为只能有一个实例去操作，否则内容不好追加。
    2.Web应用的配置对象的读取，一般也应用单例模式，这个是由于配置文件是共享的资源。
    3.数据库连接池的设计一般也是采用单例模式，因为数据库连接是一种数据库资源。数据库软件系统中使用数据库连接池，主要是节省打开或者关闭数据库连接所引起的效率损耗，这种效率上的损耗还是非常昂贵的，用单例模式来维护，就可以大大降低这种损耗。
    4.多线程的线程池的设计一般也是采用单例模式，这是由于线程池要方便对池中的线程进行控制。
    5.操作系统的文件系统，也是大的单例模式实现的具体例子，一个操作系统只能有一个文件系统。
    6. HttpApplication 也是单位例的典型应用。熟悉ASP.Net(IIS)的整个请求生命周期的人应该知道HttpApplication也是单例模式，所有的HttpModule都共享一个HttpApplication实例。
   
    简单的说说单例的目的：资源共享，避免多次创建对象，以提高性能。资源控制，方便资源之间的互相通信。

    单例模式与垃圾回收：单例模式创建的对象会不会被垃圾回收机制回收？这是一个饱受争议的问题，网上各种水平的人，包括所谓的“技术大牛”都持有不同观点。但是笔者可以在这里明确的告诉大家，一个单例对象即使长时间未被引用也不会被垃圾回收机制给卸载掉。关于垃圾回收（GC）的底层原理，不属于本文范围，在此不做过多讲解。
    原文永久地址：http://jsonliangyoujun.iteye.com/blog/2355384