对比3种单例模式

单例模式的优点

  1，实例控制：单例模式防止其它对象对自己的实例化，确保所有的对象都访问一个实例。
  2，伸缩性：因为由类自己来控制实例化进程，类就在改变实例化进程上有相应的伸缩性。
单例模式的缺点

   1，系统开销。虽然这个系统开销看起来很小，但是每次引用这个类实例的时候都要进行实例是否存在的检查。这个问题可以通过静态实例来解决。
   2，开发混淆。当使用一个单例模式的对象的时候（特别是定义在类库中的），开发人员必须要记住不能使用new关键字来实例化对象。因为开发者看不到在类库中的源代码，所以当他们发现不能实例化一个类的时候会很惊讶。

实现原则：
a.私有的静态的实例
b.私有的构造方法
c.公有静态的访问接口


第一种方法：饿汉式单例类

//========外部直接调用 DaoFactory.getInstance();静态方法即可得到当前类的实例

public class DaoFactory {
          //私有的静态的实例
	private static DaoFactory instance = new DaoFactory();
	//私有的构造方法
	private DaoFactory() {}
	//公有静态的访问接口,返回当前类的实例
	public static DaoFactory getInstance() {
		return instance;
	}
	
	}


//客户端访问
public class SingletonTest {

	
	public static void main(String []args){
		
		DaoFactory factory1=DaoFactory.getInstance();
		DaoFactory factory2=DaoFactory.getInstance();
		//判断得到的2个实例是是否相等
		if(factory1==factory2){
			System.out.print("属于同一个实例");
		}
		
	}
}

 

第二种方法：懒汉式单例类,可以同步但是效率不高：

public class Singleton { 
	
	private static Singleton instance = null; 
	public static synchronized Singleton getInstance() { 
        if(instance==null){
      
      	 instance=new Singleton();
        }
	return instance;
	
	}
   public static void main(String []args){
 
   Singleton s=Singleton.getInstance();
   Singleton s2=Singleton.getInstance();
   if(s==s2){
	   System.out.print("s==s2");
   }
}
} 

第三种，双检锁写法：
上面的第二种写法，程序不会出错，因为整个getInstance是一个整体的"critical section"，但就是效率很不好，因为我们的目的其实只是在第一个初始化instance的时候需要locking(加锁)，而后面取用instance的时候，根本不需要线程同步。
于是聪明的人们想出了下面的做法：

 public class Singleton{    
  private static Singleton single; //声明静态的单例对象的变量    
  private Singleton(){}    //私有构造方法    
      
  public static Singleton getSingle(){ //外部通过此方法可以获取对象      
    if(single == null){       
        synchronized (Singleton.class) { //保证了同一时间只能只能有一个对象访问此同步块          
            if(single == null){        
                 single = new Singleton();            
         }       
       }    
     }      
    return single; //返回创建好的对象    
   }    
}