java用sychronized实现的单例模式两种实现方式有什么区别？

[二哥的博客]

看设计模式的时候，网上有代码说，在考虑多线程的时候，用sychronized做同步的时候必须将getInstance和new操作分开，否则会有可能出错；也就是讲下面第一段代码改为第二段：

public class SingletonTest {

private static SingletonTest instance = null;

private SingletonTest() {
}


public static Singleton getInstance() {  
        if (instance == null) {  
            synchronized (instance) {  
                if (instance == null) {  
                    instance = new Singleton();  
                }  
            }  
        }  
        return instance; 
​​    }
​
}

改成：

public class SingletonTest {


private static SingletonTest instance = null;

private SingletonTest() {
}

private static synchronized void syncInit() {
if (instance == null) {
instance = new SingletonTest();
}
}

public static SingletonTest getInstance() {
if (instance == null) {
syncInit();
}
return instance;
}
}

​

网上的理由是：
在Java指令中创建对象和赋值操作是分开进行的，也就是说instance = new Singleton();语句是分两步执行的。但是JVM并不保证这两个操作的先后顺序，也就是说有可能JVM会为新的Singleton实例分配空间，然后直接赋值给instance成员，然后再去初始化这个Singleton实例。这样就可能出错了，我们以A、B两个线程为例：

a>A、B线程同时进入了第一个if判断

b>A首先进入synchronized块，由于instance为null，所以它执行instance = new Singleton();

c>由于JVM内部的优化机制，JVM先画出了一些分配给Singleton实例的空白内存，并赋值给instance成员（注意此时JVM没有开始初始化这个实例），然后A离开了synchronized块。

d>B进入synchronized块，由于instance此时不是null，因此它马上离开了synchronized块并将结果返回给调用该方法的程序。

e>此时B线程打算使用Singleton实例，却发现它没有被初始化，于是错误发生了。



看了很不理解，改进的方法不是也有同样的问题？ 两者的区别在哪儿？（对面同步就能保证instance一定是实例化之后才被使用么？）

[Inhibitory]

没啥区别

[晴天_ccc]

很明显是一样的。

[疯狂熊猫人]

两种方式都是一样的，都是“双重检查加锁”，只是写法不一样。为啥要检查两次？为了提高性能 看了你说的所谓的网上的解释，他就是在放屁，误人子弟。 1、instance = new Singleton()；是分两步，先给Singleton分配空间（但是不一定初始化它），那么就可能出现在随后的调用instance 是出现空指针异常，进一步得出结论Java是不稳定的，你认为这个结论对吗？ 2、最主要一个问题在于你所说的理论自相矛盾：A离开synchronized后将instance 返回，B紧接着进入，B得到的instance可能出现不稳定，那么A得到的instance 也应该出现不稳定才对，因为B返回instance 的时间在A后面（同一个对象，你先拿到是初始化的，我后拿到反而变为未初始化了），那么在此得出与1相同的结论，java不稳定，对吗？ 另外，synchronized代码块只会有一个线程能够进入其中，如果抢到锁的线程未释放锁，那么其他的线程是不能进入该代码块的。

[二哥的博客]

受用了！感谢6楼的细致和7楼的精辟，结帖结贴！ PS：达叔真是帅的掉渣PS：达叔真是帅的掉渣

[scmod]

instance == null为啥要判断两遍啊? 一遍直接synchronized整个方法不是就可以了? 不是很会....

[二哥的博客]

引用 3 楼 scmod 的回复:

instance == null为啥要判断两遍啊? 一遍直接synchronized整个方法不是就可以了? 不是很会....

直接对方法加synchronized会导致效率下降，因为是对整个对象进行了加锁同步，这就会印象getInstance的效率

[scmod]

引用 4 楼 abcd_d_ 的回复:

[quote=引用 3 楼 scmod 的回复:] instance == null为啥要判断两遍啊? 一遍直接synchronized整个方法不是就可以了? 不是很会....

直接对方法加synchronized会导致效率下降，因为是对整个对象进行了加锁同步，这就会印象getInstance的效率[/quote] 但是整个对象不就这个方法并没有别的方法.... 而且没有必要判断两遍..同步另外个对象就可以取消第一个判断

[youshu2011]

两段代码没啥区别，只是写法不同，关键在于instance == null要判断两次，第一次不加synchronized，第二次加synchronized if (instance == null) 和 instance = new Singleton()这两段代码的执行是有时差的。 一个线程执行if (instance == null) 为true，接着执行instance = new Singleton()，在这过程中另一个线程也可能执行if (instance == null) 为true，接着执行instance = new Singleton()，这样就会执行多次instance = new Singleton()，导致数据混乱。 因此if (instance == null) {instance = new Singleton(); }过程需要加上synchronized来保证数据同步，但instance == null条件只在第一次执行的时候会为true，以后都是false，但使用synchronized会性能下降，所以先进行一次不加synchronized的判断，降低使用synchronized次数。 看看下面两段代码的输出内容你就懂了。

public class SingletonTest {
	private static SingletonTest instance = null;
	public static void main(String[] args) {
		for (int i = 0; i < 100000; i++) {
			new Thread(new Runnable() {
				
				@Override
				public void run() {
					getInstance1();
					
				}
			}).start();
		}

	}
	public static SingletonTest getInstance1() {
		if (instance == null) {  
            synchronized (SingletonTest.class) {  
            	System.out.println("synchronized");
                if (instance == null) {  
                	System.out.println("new");
                    instance = new SingletonTest();  
                }  
            }  
        }  
        return instance; 
	}
}

public class SingletonTest {
	private static SingletonTest instance = null;
	public static void main(String[] args) {
		for (int i = 0; i < 100000; i++) {
			new Thread(new Runnable() {
				
				@Override
				public void run() {
					getInstance2();
					
				}
			}).start();
		}

	}
	public static SingletonTest getInstance2() {
        synchronized (SingletonTest.class) {  
        	System.out.println("synchronized");
            if (instance == null) {  
            	System.out.println("new");
                instance = new SingletonTest();  
            }  
        }  
        return instance; 
	}
}

[zhangfeng185703]

第一种写法需要将 instance 加上 volatile 修饰。