单例设计模式

饿汉式：

 class Single
 {
     private static final Single s=new Single();
     private Single(){}
     public static Single getInstance()
     {
        return s;
    }
}

对象s被static修饰，表明类加载时就会创建这个对象，被final修饰，表明不可被修改，然后用private修饰构造方法，表明不能被其他类调用去创建对象，这样的话能保证s是唯一的，实现了单例，这种方法是最简单的，但是一般面试的时候不问这种，一般都是问懒汉式，接下来我们说说懒汉式。

懒汉式就是延迟创建对象，首先我们来看看不加同步的懒汉式：

 class Single
	 {
	     private static  Single s=null;
	     private Single(){}
	     public static Single getInstance()
	     {
	         if(s==null){
	            //-->thread-0    thread-1
	        	 s=new Single();
	         }
	         return s;
	     }
	 }

这样可能发生的情况是，两个线程同时通过if判断，这样的话就会new两个对象，无法实现单例，所以接下来我们加上同步。

加上同步的懒汉式：

 class Single
	 {
	     private static  Single s=null;
	     private Single(){}
	     public static Single getInstance()
	     {
	             synchronized (Single.class)
	             {
	                 if(s==null)
	                     s=new Single();
	             }
	         
	         return s;
	     }
	 }

在if判断外加上同步后，同一时间只有一个线程进入判断，当第一个线程创建对象后，后面的线程就不会创建对象了，可以实现单例，但是这样的话，如果有很多个线程来访问，每个线程都要通过synchronize同步锁的判断，会降低效率，所以我们做如下改造。

优化后的带同步的懒汉式：

 class Single
	 {
	     private static  Single s=null;
	     private Single(){}
	     public static Single getInstance()
	     {
	         //通过双重判断，减少判断锁的次数，稍微提高效率。
	         if (s==null)
	         {
	             synchronized (Single.class)
	             {
	                 if(s==null)
	                     s=new Single();
	             }
	         }
	         return s;
	     }
	 }

我们在外面加一个判断对象是否为空的判断，当第一个线程创建对象后，s不为空，后面的线程就不用判断锁了，直接返回s，因为对于锁的判断，还有线程等待，这些都是很降低效率的，所以我们更加愿意采用不怎么耗费效率的if语句，代替锁的判断和等待。