单例模式的八种实现方式

1.单例模式概述

        在一个软件系统中，对某个类只能存在一个对象实例，并且该类只提供可一个获取实例的静态方法（比如Hibernate的SessionFactory，它充当数据存储源的代理，并负责创建Session对象。SessionFactory并不是轻量级的，一般情况下，一个项目通常只需要一个SessionFactory就够，这是就会使用到单例模式。）

2.单例模式实现

（1）饿汉式（静态常量）：实现简单，会造成不必要的内存开销，不建议使用

//	饿汉式，静态变量完成
class Singleton01 {
	//	1，构造器私有化
	private Singleton01() {
		
	}
	//	2，本类内部创建实例
	private static final Singleton01 s = new Singleton01();
	
	//	3，对外提供一个公有的访问方法
	public static Singleton01 getInstance() {
		return s;
	}
}

（2）饿汉式（静态代码块）：实现简单，也会造成不必要的内存开销，不建议使用

//	饿汉式，静态代码块完成
class Singleton02 {
	//	1，构造器私有化
	private Singleton02() {
		
	}
	//	2，本类内部创建实例
	private static Singleton02 s;
	static {
		s = new Singleton02();
	}
	
	//	3，对外提供一个公有的访问方法
	public static Singleton02 getInstance() {
		return s;
	}
}

（3）懒汉式（线程不安全）：由于线程不安全，在并发场景不能保证只创建一个对象，因此不建议使用

//	懒汉式
class Singleton03 {
	//	1，构造器私有化
	private Singleton03() {
		
	}
	//	2，本类内部创建实例
	private static Singleton03 s;
	
	//	3，对外提供一个公有的访问方法
	public static Singleton03 getInstance() {
		if(s == null) {
			s = new Singleton03();
		}
		return s;
	}
}

（4）懒汉式（同步方法）：在多线程每次都使用synchronized进行创建，效率降低，不建议使用

//	懒汉式,通过synchronized保证原子性
class Singleton04 {
	//	1，构造器私有化
	private Singleton04() {
		
	}
	//	2，本类内部创建实例
	private static Singleton04 s;
	
	//	3，对外提供一个公有的访问方法
	public static synchronized Singleton04 getInstance() {
		if(s == null) {
			s = new Singleton04();
		}
		return s;
	}
}

（5）懒汉式（在内部进行synchronized）：这种方式并不能保证在并发场景中只创建一个对象，当多个线程都进入到if中一个一个进入创建，所以这种方式是不可取的

class Singleton05 {
	//	1，构造器私有化
	private Singleton05() {
		
	}
	//	2，本类内部创建实例
	private static Singleton05 s;
	
	//	3，对外提供一个公有的访问方法
	public static Singleton05 getInstance() {
		if(s == null) {
			synchronized(Singleton05.class) {
				s = new Singleton05();
			}
		}
		return s;
	}
}

（6）静态内部类：

1)这种方式采用了类装载的机制来保证初始化实例时只有一个线程。
2)静态内部类方式在Singleton类被装载时并不会立即实例化，而是在需要实例化
时，调用getInstance方法，才会装载SingletonInstance类，从而完成Singleton的实例化。
3)类的静态属性只会在第一次加载类的时候初始化，所以在这里，JⅣM帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的。
4)优点:避免了线程不安全，利用静态内部类特点实现延迟加载，效率高

5)结论:推荐使用.

//	采用静态内部类的方式
class Singleton07 {
	//	1，构造器私有化
	private Singleton07() {
		
	}
	//	写一个静态内部类，里面有一个静态内部类属性
	private static class singletonIntance {
		private static final Singleton07 s = new Singleton07();
	}
	//	提供一个静态公共方法，直接返回singletonIntance.s
	public static Singleton07 getInstance() {
		return singletonIntance.s;
	}
}

（7）双重检查：

  在并发中，如果多个线程一起进入，这种方式可以保证只有一个对象进行创建，创建成功之后其余线程可能会被第一个if栏在外面，因此这种方式是建议使用的，解决线程安全问题，也解决懒加载问题，同时保证效率

//	采用双重检查的方式
class Singleton06 {
	//	1，构造器私有化
	private Singleton06() {
		
	}
	//	2，本类内部创建实例
	private static Singleton06 s;
	
	//	3，对外提供一个公有的访问方法
	public static Singleton06 getInstance() {
		if(s == null) {
			synchronized(Singleton06.class) {
				if(s == null) {
					s = new Singleton06();
				}
				
			}
		}
		return s;
	}
}

（8）枚举：

1)这借助JDK1.5中添加的枚举来实现单例模式。不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象。
2)这种方式是Effective Java作者Josh Bloch提倡的方式

3)结论:推荐使用

//	枚举
enum Singleton08 {
	s;	//	属性
}