java用sychronized实现的单例模式两种实现形式有什么区别
java用sychronized实现的单例模式两种实现方式有什么区别？
看设计模式的时候，网上有代码说，在考虑多线程的时候，用sychronized做同步的时候必须将getInstance和new操作分开，否则会有可能出错；也就是讲下面第一段代码改为第二段：
改成：
网上的理由是：
在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一定是实例化之后才被使用么？）
------解决思路----------------------
没啥区别
------解决思路----------------------
很明显是一样的。
------解决思路----------------------
instance == null为啥要判断两遍啊?
一遍直接synchronized整个方法不是就可以了?
不是很会....
------解决思路----------------------
但是整个对象不就这个方法并没有别的方法....
而且没有必要判断两遍..同步另外个对象就可以取消第一个判断
------解决思路----------------------
两段代码没啥区别，只是写法不同，关键在于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次数。
看看下面两段代码的输出内容你就懂了。
------解决思路----------------------
两种方式都是一样的，都是“双重检查加锁”，只是写法不一样。为啥要检查两次？为了提高性能
看了你说的所谓的网上的解释，他就是在放屁，误人子弟。
1、instance = new Singleton()；是分两步，先给Singleton分配空间（但是不一定初始化它），那么就可能出现在随后的调用instance 是出现空指针异常，进一步得出结论Java是不稳定的，你认为这个结论对吗？
2、最主要一个问题在于你所说的理论自相矛盾：A离开synchronized后将instance 返回，B紧接着进入，B得到的instance可能出现不稳定，那么A得到的instance 也应该出现不稳定才对，因为B返回instance 的时间在A后面（同一个对象，你先拿到是初始化的，我后拿到反而变为未初始化了），那么在此得出与1相同的结论，java不稳定，对吗？
另外，synchronized代码块只会有一个线程能够进入其中，如果抢到锁的线程未释放锁，那么其他的线程是不能进入该代码块的。
看设计模式的时候，网上有代码说，在考虑多线程的时候，用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一定是实例化之后才被使用么？）
------解决思路----------------------
没啥区别
------解决思路----------------------
很明显是一样的。
------解决思路----------------------
instance == null为啥要判断两遍啊?
一遍直接synchronized整个方法不是就可以了?
不是很会....
------解决思路----------------------
但是整个对象不就这个方法并没有别的方法....
而且没有必要判断两遍..同步另外个对象就可以取消第一个判断
------解决思路----------------------
两段代码没啥区别，只是写法不同，关键在于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;
}
}
------解决思路----------------------
两种方式都是一样的，都是“双重检查加锁”，只是写法不一样。为啥要检查两次？为了提高性能
看了你说的所谓的网上的解释，他就是在放屁，误人子弟。
1、instance = new Singleton()；是分两步，先给Singleton分配空间（但是不一定初始化它），那么就可能出现在随后的调用instance 是出现空指针异常，进一步得出结论Java是不稳定的，你认为这个结论对吗？
2、最主要一个问题在于你所说的理论自相矛盾：A离开synchronized后将instance 返回，B紧接着进入，B得到的instance可能出现不稳定，那么A得到的instance 也应该出现不稳定才对，因为B返回instance 的时间在A后面（同一个对象，你先拿到是初始化的，我后拿到反而变为未初始化了），那么在此得出与1相同的结论，java不稳定，对吗？
另外，synchronized代码块只会有一个线程能够进入其中，如果抢到锁的线程未释放锁，那么其他的线程是不能进入该代码块的。