设计模式：单例模式，懒汉与饿汉

在某些情况下，有些对象只需要一个就可以了，换句话说，每个类只需要一个实例。比如，一台计算机连接多台打印机，但这个计算机上打印程序只能有一个，这里就需要单例模式来避免打印机左右同时输入到打印机中。、

单例模式的作用就是保证整个应用程序的生命周期中，任何一个时刻，单例类的实例都只存在一个。单例模式主要有三个特点：

1. 单例类只能有一个实例

2. 单例类必须创建自己唯一的实例。

3. 单例类必须为其他对象提供这一实例。

那么如何实现满足上述条件的单例类呢？答案是：

1. 私有构造方法。

2. 内部创建静态对象。

3. 提供静态方法返回该静态对象。

 

单例设计模式主要有两种实现方法：饿汉式和懒汉式。

 

1. 饿汉式单例：在定义开始，便实例化自己。

 

public class Single0 {
	private Single0() {
		//私有构造方法
	}
	private static Single0 s=new Single0();//内部创建静态方法，实例化
	public static Single0 getsingle() {
		return s;//提供静态方法，返回对象
	}
}

2. 懒汉式单例：在第一次调用时实例化自己。

 

class Single1{
	private Single1() {
		//私有构造方法
	}
	public static Single1 s=null;
	public static Single1 getsingle() {
		s=new Single1();//实例化
		return s;
	}
}

那饿汉式和懒汉式分别有什么区别呢？

1. 线程安全：

饿汉式天生线程安全，可以直接用于多线程而不会出现问题。

懒汉式本身非线程安全，需要人为实现线程安全。

2. 资源加载和性能：

饿汉式在类创建的同时就实例化一个静态对象出来，不管之后会不会使用这个单例，都会占据一定的内存，造成内存泄漏，但相应的，在第一次调用时速度也会更快。

而懒汉式顾名思义，会延迟加载，在第一次使用该单例的时候才会实例化对象出来，第一次调用时要做初始化，如果要做的工作比较多，性能上会有些延迟，之后就和饿汉式一样了。

 

为了保证懒汉式的线程安全，通常有三种方法：

1. 全局访问点加同步。

由于synchronized是锁方法, 当两个线程都要进入getsingle()时, 只有一个能进入, 并创建出实例, 然后另外一个进入后, 判断 s不为null, 然后直接得到s。 这种做法是没有错误的. 但是由于线程都需要通过getsingle()来获取对象, 所以getsingle()调用频率很高, 所以线程被锁的频率也很高, 所以这种做法效率低。简言之，不管对象有没有被创建，其余线程都只能等待这个方法的锁。

class Single1{
	private Single1() {
		//私有构造方法
	}
	public static Single1 s=null;
	public static synchronized Single1 getsingle() {
		s=new Single1();//实例化
		return s;
	}
}

2. 双重检查锁定。

由于上述都是在等待同步方法的锁，很容易想到把synchronized放在方法里面，这样可以避免方法的阻塞。

 

class Single2{
	private Single2() {
		//私有构造方法
	}
	public static Single2 s=null;
	public static Single2 getsingle() {
		if(s==null) {
			synchronized(Single2.class) {
					s=new Single2();//实例化
			}
		}
		return s;
	}
}

这种写法看似没有问题, 其实却有一个很大的隐患, 在于：如果两个线程同时执行getsingle(),判断 instance都不为null后, 进入if判断语句。这个时候一个线程获得锁, 然后进入new了一个对象, 并开心地执行完了。这个时候另外一个线程获得了锁, 但让它也不会再去判断 s是否为null，所以它也会再执行一次new操作。所以这里执行了两次new操作。当然最后s还是只指向后一次new的对象。
所以这个时候需要双重锁定, 就是在 synchronized中再加一次 null判断, 如下:

 

class Single3{
	private Single3() {
		//私有构造方法
	}
	public static Single3 s=null;
	public static Single3 getsingle() {
		if(s==null) {
			synchronized(Single3.class) {
				if(s==null) {
					s=new Single3();//实例化
				}
			}
		}
		return s;
	}
}

3. 静态内部类：既实现了线程安全，又避免了同步带来的性能影响。