设计模式之一：单例模式、懒式以及饿汉式

1.单例模式：
在系统运行的任何时刻，单例模式的实例都只存在一个。（一台连着多台打印机的计算机，计算机的打印程序只能有一个，这时候需要单例模式来避免打印机同时运行）
单例模式的特点：
1.单例类只有一个实例。
2.单例类必须创建自己唯一的实例。
3.单例类必须为其他对象提供这一实例。
如何实现：
1.私有构造方法。
2.内部创建静态对象。
3.提供静态方法返回该静态对象。
2.懒汉式单例模式
在定义开始，便实例化自己。

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

3.懒汉式单例模式
第一次调用的时候，实例化自己。

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

懒汉式和饿汉式的区别：
1.在线程安全方面：
饿汉式天生线程安全，可以直接用于多线程。
懒汉式非线程安全，需要人为实现线程安全。
2.资源加载和性能。
饿汉式在类创建时就实例化一个静态对象，之后不管会不会使用，都会占用一定的内存，可能造成内存泄漏，但是第一次调用的速度会更快。
懒汉式，在加载式会有延迟，第一使用该实例时，才会实例化对象，第一次调用要初始化，要做的工作较多，性能上会有延迟，之后和饿汉模式一样。
如果单件模式实例在系统中经常会被用到，饿汉式是一个不错的选择。
反之如果单件模式在系统中会很少用到或者几乎不会用到，那么懒汉式是一个不错的选择。
为了保证懒汉模式的线程安全，一般有三种方法：
1.全局访问点加同步。
用synchronized关键字实现线程同步，当两个线程同时进入getSingle(),只有一个能进如，并创建实例。然后另外一个进入后，判断s是否为空，不为空直接得到s值由于线程都需要通过getsingle()来获取对象, 所以getsingle()调用频率很高, 所以线程被锁的频率也很高, 所以这种做法效率低。简言之，不管对象有没有被创建，其余线程都只能等待这个方法的锁。

class Single1{
	private Single1(){
	}
	public static Single1 s=null;
	public static synchornized single1 getSingle(){
		s=new Single1();//实例化
		return s;
}
}

2.双重检查锁定。

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

class Single1{
	private Single1(){
	}
	public static Single1 s=null;
	public static  single1 getSingle(){
		if(s==null){
			synchronized(Single1.class){
			s=new Single1();
			}
		}
		return s;
}
}

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

class Single1{
	private Single1(){
	}
	public static Single1 s=null;
	public static  single1 getSingle(){
		if(s==null){
			synchronized(Single1.class){
				if(s==null){
					s=new Single1();
				}
			
			}
		}
		return s;
}
}