单例模式总结

昨天看了下单例模式的一些内容，就想做下总结。巩固一下自己所学的知识。在写之前先说一下什么是设计模式？简单的理解就是前人的经验总结。通过设计模式可以让我们的代码复用性更高，可维护性更高，让你的代码写的更优雅。

单例模式的目的：

希望对象只创建一个实例，并且提供一个全局的访问点。

运用的场合：

有些对象只需要一个就足够了，如线程池、缓存、配置文件、工具类、日志对象等。如果创造出多个实例，就会导致出现一些问题，比如：占用过多资源，不一致的结果等。

作用：

保证整个应用程序中某个实例有且只有一个。

类型：

常用的单例模式主要有两种：饿汉模式、懒汉模式。

饿汉模式(线程安全)

public class Singleton {
	//1.将构造方法私有化，不允许外部直接创建对象
	private Singleton(){		
	}
	
	//2.创建类的唯一实例，使用private static修饰
	private static Singleton instance=new Singleton();
	
	//3.提供一个用于获取实例的方法，使用public static修饰
	public static Singleton getInstance(){
		return instance;
	}
}

代码很简单，这就是饿汉模式。在加载类的时候就会创建类的实例。如果单例对象初始化非常快，而且占用内存非常小的时候这种方式是比较合适的，可以直接在应用启动时加载并初始化。

这到底是不是真的只有一个实例呢？我们可以简单的写一个Test类测试一下。代码如下

public class Test {
	public static void main(String[] args) {
		//饿汉模式
		Singleton s1=Singleton.getInstance();
		Singleton s2=Singleton.getInstance();
		if(s1==s2){
			System.out.println("s1和s2是同一个实例");
		}else{
			System.out.println("s1和s2不是同一个实例");
		}
}

输出的结果是：s1和s2是同一个实例。所以是真的只有一个实例。

懒汉模式（线程不安全）

public class Singleton {
	//1.将构造方式私有化，不允许外边直接创建对象
	private Singleton(){
	}
	
	//2.声明类的唯一实例，使用private static修饰
	private static Singleton instance;
	
	//3.提供一个用于获取实例的方法，使用public static修饰
	public static Singleton getInstance(){
		if(instance==null){
			instance=new Singleton();
		}
		return instance;
	}
}

这就是懒汉模式。加载类的时候只是声明类的实例，需要使用的时候再实例化。如果单例用到次数不是很多，但是这个单例提供的功能又非常复杂，而且加载和初始化要消耗大量的资源，这个时候使用懒汉式就是非常不错的选择。

区别

饿汉模式的特点是加载类时比较慢，但运行时获取对象的速度比较快，线程安全。懒汉模式的特点是加载类时比较快，但运行时获取对象的速度比较慢，线程不安全。

懒汉模式改进方法：

上面介绍的懒汉模式是线性不安全的。我们来说一下什么情况下这种写法会有问题。在运行过程中可能存在这么一种情况：有多个线程去调用getInstance方法来获取Singleton的实例，那么就有可能发生这样一种情况当第一个线程在执行if(instance==null)这个语句时，此时instance是为null的进入语句。在还没有执行instance=new Singleton()时(此时instance是为null的)第二个线程也进入if(instance==null)这个语句，因为之前进入这个语句的线程中还没有执行instance=new Singleton()，所以它会执行instance=new Singleton()来实例化Singleton对象，因为第二个线程也进入了if语句所以它也会实例化Singleton对象。这样就导致了实例化了两个Singleton对象。所以单例模式的懒汉式是存在线程安全问题的，既然它存在问题，那么可能有解决这个问题的方法，那么究竟怎么解决呢？对这种问题可能很多人会想到加锁于是出现了下面这种写法。

加锁的懒汉模式（线性安全，效率低，不推荐）

public class Singleton {
	//1.将构造方式私有化，不允许外边直接创建对象
	private Singleton(){
	}
	
	//2.声明类的唯一实例，使用private static修饰
	private static Singleton instance;
	
	//3.提供一个用于获取实例的方法，使用public static synchronized修饰
	public static synchronized Singleton getInstance(){
		if(instance==null){
			instance=new Singleton();
		}
		return instance;
	}
}

只是多了一个synchronized修饰，但是这种懒汉模式是线性安全的，只是效率很低，不推荐使用。每个线程在想获得类的实例时候，执行getInstance()方法都要进行同步。而其实这个方法只执行一次实例化代码就够了，后面的想获得该类实例，直接return就行了。方法进行同步效率太低要改进。
于是，我们可能会想到下面这种方式。

进一步改写的懒汉模式（线性不安全，不推荐）

public class Singleton {
	// 1.将构造方式私有化，不允许外边直接创建对象
	private Singleton() {
	}

	// 2.声明类的唯一实例，使用private static修饰
	private static Singleton instance;

	// 3.提供一个用于获取实例的方法，使用public static synchronized修饰
	public static Singleton getInstance() {
		if (instance == null) {
			synchronized (Singleton.class) {
				instance = new Singleton();
			}
		}
		return instance;
	}
}

可是这种方法也是线性不安全的。当一个线程还没有实例化Singleton时另一个线程执行到if(instance==null)这个判断语句时就会进入if语句，虽然加了锁，但是等到第一个线程执行完instance=new Singleton()跳出这个锁时，另一个进入if语句的线程同样会实例化另外一个Singleton对象，线程不安全的原理跟上面的类似。

最后，我们想到了双重校验锁。这种方法是推荐使用的懒汉模式！

懒汉模式双重校验锁（线性安全，效率较高，推荐使用）

public class Singleton {
	// 1.将构造方式私有化，不允许外边直接创建对象
	private Singleton() {
	}

	// 2.声明类的唯一实例，使用private static修饰
	private static Singleton instance;

	// 3.提供一个用于获取实例的方法，使用public static synchronized修饰
	public static Singleton getInstance() {
		if (instance == null) {
			synchronized (Singleton.class) {
				if (instance == null) {
					instance = new Singleton();
				}
			}
		}
		return instance;
	}
}

其实还有两种单例的写法：静态内部类和枚举。有兴趣的自己去查看下资料吧。