单例模式

单例模式的特点

1.单例模式只能有一个实例

2.单例模式必须自己创建自己的唯一实例

3.单例模式必须给其他对象提供这一实例

单例模式实现方法

1.饿汉式（线程安全）

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

这种方式基于classloder的机制避免的多线程的同步问题，但并没有达到延迟加载的效果

2.懒汉式

2.1线程不安全的懒汉式

public class Singleton {
    private static Singleton instance;
    private Singleton (){}

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

2.2线程安全但是效率低的懒汉式

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

这种写法能够在多线程中很好的工作，而且看起来它也具备很好的lazy loading，但是，遗憾的是，效率很低，99%情况下不需要同步。

2.3双重校验锁

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;
    }
}

2.2的升级版
需要注意的是，如果使用双重检查锁定来实现懒汉式单例类，需要在静态成员变量之前增加volatile修饰符，被修饰的成员变量可以确保多个线程都能够正确处理，且该代码只能在JDK 1.5及以上版本中才能正确执行。由于volatile关键字会屏蔽虚拟机所做的一些代码优化，可能会导致系统运行效率降低，因此即使使用双重检查锁定来实现单例模式也不是一种完美的实现方式

3静态内部类

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

这种方式同样利用了classloder的机制来保证初始化instance时只有一个线程，它跟饿汉式不同的是：饿汉式是只要Singleton类被装载了，那么instance就会被实例化（没有达到lazy loading效果），而这种方式是Singleton类被装载了，instance不一定被初始化。因为SingletonHolder类没有被主动使用，只有显示通过调用getInstance方法时，才会显示装载SingletonHolder类，从而实例化instance

4.枚举

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

自由序列化；保证只有一个实例（即使使用反射机制也无法多次实例化一个枚举量）；线程安全；

总结

恶汉：因为加载类的时候就创建实例，所以线程安全(多个ClassLoader存在时例外)。缺点是不能延时加载。
懒汉：需要加锁才能实现多线程同步，但是效率会降低。优点是延时加载。
双重校验锁：麻烦，在当前Java内存模型中不一定都管用。
静态内部类：延迟加载，减少内存开销。因为用到的时候才加载，避免了静态field在单例类加载时即进入到堆内存的permanent代而永远得不到回收的缺点(大多数垃圾回收算法是这样)。
枚举：很好，不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象。但是失去了类的一些特性，没有延迟加载。

参考文章：

http://callmegod.iteye.com/blog/1474441

http://blog.csdn.net/likika2012/article/details/11483167

http://cantellow.iteye.com/blog/838473 http://blog.csdn.net/jason0539/article/details/23297037