关于synchronized的三个简单实例

第一种：

1. public class Singleton2 {  
2.       
3.     private Singleton2(){  
4.         System.out.println("This is Singleton2's instance.");  
5.     };  
6.       
7.     private static Singleton2 instance = null;  
8.       
9.     public static Singleton2 getInstance(){  
10.         if(instance == null) {  
11.             instance = new Singleton2();  
12.         }  
13.         return instance;  
14.     }  
15. }  

这种情况未加锁，可能会产生数据错误，比如两个同时新生成的对象，一个把对象数据改变了，而另一个使用的没改变之前的

第二种：

1. public class Singleton1 {  
2.       
3.     private Singleton1(){  
4.         System.out.println("This is Singleton1's instance.");  
5.     }  
6.       
7.     private static Singleton1 instance = null;  
8.   
9.     public static Singleton1 getInstance2() {  
10.         if(instance == null){   //1  
11.             synchronized (Singleton1.class) {  //2  
12.                 if(instance == null) {  
13.                     instance = new Singleton1();  
14.                 }  
15.             }  
16.         }  
17.         return instance;  
18.     }  
19.       
20. }  

这种只会在第一次的时候产生阻塞，之后每实例一次对象，就会在第1步时跳过去，在第一次实例的时候，会在第2步那里产生阻塞，以后就不会了，这种相对来说是最好的

第三种：

1. public class Singleton1 {  
2.       
3.     private Singleton1(){  
4.         System.out.println("This is Singleton1's instance.");  
5.     }  
6.       
7.     private static Singleton1 instance = null;  
8.       
9.     public static synchronized Singleton1 getInstance(){  //1  
10.           
11.         if(instance == null){  
12.             instance = new Singleton1();  
13.         }  
14.         return instance;  
15.     }  
16. }  

多线程的时候每次都会在1这里产生阻塞。

附上原帖地址：http://blog.csdn.net/withiter/article/details/8140338