单例模式

模式介绍

所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中， 对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法(静态方法)。

比如 Hibernate 的 SessionFactory， 它充当数据存储源的代理， 并负责创建 Session 对象。SessionFactory 并不是轻量级的， 一般情况下， 一个项目通常只需要一个 SessionFactory 就够，这是就会使用到单例模式。

七种单例模式

单例模式有七种方式之多，分别为 饿汉式(静态常量)、饿汉式（静态代码块）、懒汉式(线程不安全)、懒汉式(线程安全， 同步方法)、双重检查、静态内部类和枚举。

饿汉式（静态常量）

代码实现

// 饿汉式（静态常量）
public class Singleton1 {

	// 1.构造器私有化 (防止 new )
	private Singleton1() {
		
	}
	// 2.类的内部创建对象
	private static Singleton1 instance = new Singleton1();
	
	// 3.向外暴露一个静态的公共方法getInstance。
	public static Singleton1 getInstance() {
		return instance;
	}
	
}

优缺点说明

优点： 这种写法比较简单， 就是在类装载的时候就完成实例化， 避免了线程同步问题。
缺点： 在类装载的时候就完成实例化， 没有达到 Lazy Loading 的效果。 如果从始至终从未使用过这个实例， 则会造成内存的浪费。

结论： 这种单例模式可用， 可能造成内存浪费。

饿汉式（静态代码块）

代码实现

public class Singleton2 {

	private Singleton2() {
		
	}
	
	public static Singleton2 instance;
	
	// 在静态代码块中， 创建单例对象
	static {
		instance = new Singleton2();
	}
	
	public static Singleton2 getInstance() {
		return instance;
	}
}

优缺点说明

这种方式和上面的方式其实类似， 只不过将类实例化的过程放在了静态代码块中， 也是在类装载的时候就执行静态代码块中的代码以初始化类的实例。 优缺点和上面是一样的。

结论： 这种单例模式可用， 但是可能造成内存浪费。

懒汉式(线程不安全)

代码实现

public class Singleton3 {

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

优缺点说明

1.起到了 Lazy Loading 的效果， 但是只能在单线程下使用。
2.如果在多线程下， 一个线程进入了 if (singleton == null)判断语句块， 还未来得及往下执行， 另一个线程也通过了这个判断语句， 这时便会产生多个实例。 所以在多线程环境下不可使用这种方式

结论： 在实际开发中， 不要使用这种方式。

懒汉式(线程安全)

代码实现

// 懒汉式（线程安全）
public class Singleton4 {

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

优缺点说明

优点 ：解决了线程安全问题
缺点：效率太低， 每个线程在想获得类的实例时候， 执行 getInstance()方法都要进行同步。 而其实这个方法只执行一次实例化代码就够了， 后面的想获得该类实例， 直接 return 就行了。

结论： 在实际开发中， 不推荐使用这种方式。

双重检查

代码实现

public class Singleton5 {
	private Singleton5() {}
	
	// volatile 关键字防止instance实例化与instance赋值（地址）的指令重排序
	// 因为当线程1执行了instance = new Singleton5()；操作时，可能仅给变量instance赋了地址而还没实例化，
	// 这就会导致线程2在判断完第一个if语句后直接返回未实例化完成的instance。
	private static volatile Singleton5 instance;
	
	public static Singleton5 getInstance() {
		if (instance == null) {
			// synchronized保持线程同步及内存可见性
			synchronized (Singleton5.class) {
				if (instance == null) {
					instance = new Singleton5();
				}
			}
		}
		return instance;
	}
}

优缺点说明

Double-Check 概念是多线程开发中常使用到的， 如代码中所示， 我们保证了线程安全。同时有延迟加载效率较高的优点。

结论： 在实际开发中， 推荐使用这种单例设计模式。

静态内部类

代码实现

public class Singleton6 {

	private Singleton6() {}
	
	// 静态内部类
	private static class SingletonInstance {
		private static Singleton6 instance = new Singleton6();
	}
	
	public static Singleton6 getInstance() {
		return SingletonInstance.instance;
	}
}

优缺点说明

静态内部类方式在 Singleton 类被装载时并不会立即实例化， 而是在需要实例化时。即调用 getInstance 方法时， 才会装载 SingletonInstance 类， 从而完成 Singleton 的实例化。所以这种方式支持延迟加载。

类的静态属性只会在第一次加载类的时候初始化， 所以在这里， JVM 帮助我们保证了线程的安全性， 在类进行初始化时， 别的线程是无法进入的。

结论： 推荐使用。

枚举

代码实现

public enum Singleton7 {
	INSTANCE;
	
	//...
}

优缺点说明

这借助枚举来实现单例模式。 不仅能避免多线程同步问题， 而且还能防止反序列化重新创建新的对象。

结论： 推荐使用。

单例模式在 JDK 应用的源码分析

在 JDK 中， java.lang.Runtime 就是经典的单例模式(饿汉式)，具体如下图所示：

单例模式注意事项和细节说明

单例模式保证了系统内存中该类只存在一个对象， 节省了系统资源， 对于一些需要频繁创建销毁的对象， 使用单例模式可以提高系统性能。

当想实例化一个单例类的时候， 必须要记住使用相应的获取对象的方法， 而不是使用 new。

单例模式使用的场景： 需要频繁的进行创建和销毁的对象、 创建对象时耗时过多或耗费资源过多(即： 重量级对象)， 但又经常用到的对象、 工具类对象、 频繁访问数据库或文件的对象(比如数据源、 session 工厂等)。