单例模式线程安全

线程安全问题：这里指的是获取单例对象时候的问题，不是对象共享资源修改时候的问题。

 

双重锁定：“二次判断” ，不用每个线程在执行这个方法之前都会去等待获得锁。

如果不加同步，多个线程创建多个对象的问题，后一个覆盖前一个。 

if(instance==null) 
{
instance=new Singleton();
}

    private Singleton(){}
	private volatile static Singleton instance = null;
	public static Singleton getInstance() {
		if (instance == null) {
                    //synchronized (this)   
	             synchronized (Singleton.class) {
				if (instance == null) {
					instance = new Singleton();
				}
			}
		}
		
		return instance;
	} 

 

 

 类加载时候初始化对象： 不能延迟加载（对象大的时候，是一种空间浪费），适合类初始化时候就需要加载的场景。

public class Singleton { 

private Singleton(){ 
  
} 
//也可以不用加final,加上也行。因为私有构造方法，和私有属性可以保证其它类调用不会修改instance 。
private static Singleton instance =new Singleton(); 
public static Singleton getInstance(){ 
      return instance; 
} 

} 

  

 

static 内部类，延迟加载，使用虚拟机同步机制，不需要加synchronized 

 

public class Singleton    
{    
    private static class SingletonHolder    
    {    
        public final static Singleton instance = new Singleton();    
    }    
   
    public static Singleton getInstance()    
    {    
        return SingletonHolder.instance;    
    }    
}  

 

 

 

 

评论

3 楼 animalfishyu 2013-05-24  

其实你没觉得synchronized 方法代价有些过高么，每个线程在执行这个方法之前都会去等待获得锁，执行之后释放锁，建议锁粒度变小，采用比较常用的“二次判断”
 
private static Singleton instance =new Singleton();  
 
public static synchronized Singleton getInstance(){
      if (null == instance)
      {
            synchronized (Singleton.class)
            {
                if (null == instance)
                {
                     instance = new Singleton();
                }
            }
      }
      return instance;  
} 

另外注意instance 的可见性问题，建议加上volatile关键字

2 楼 yunhaifeiwu 2013-05-24  

//也可以不用加final,加上也行。因为私有构造方法，和私有属性可以保证其它类调用不会修改instance 。 
private static Singleton instance =new Singleton();

不同序列法，不同类加载器， 都有可能造成单例不单例

1 楼 teasp 2013-05-24  

你的代码里面可以不用synchronized。你说的几种锁，搞点java代码看看？自旋锁不是排它锁吗？