Java学习之线程锁--单例模式写法--synchronized

单例设计模式：
1）：懒汉式：（不一定安全，确保只有一份对象需要synchronized）
1.构造器私有化
2.声明私有的静态属性
3.对外提供访问属性的静态方法，确保该对象存在。
（1）：写法，多线程下不安全
[java] view plain copy 

1. public class TestSingeton02 {  
2.   
3.     private static TestSingeton02 instance;  
4.     private TestSingeton02(){         
5.     }  
6.     public static TestSingeton02 getInstance(){  
7.         if(null == instance){  
8.             instance = new TestSingeton02();  
9.         }  
10.         return instance;  
11.     }  
12. }  

（2）：写法，加锁
[java] view plain copy 

1. public static  TestSingeton02 getInstance3(){  
2.         if(null == instance){//提高已经存在的对象访问效率  
3.             synchronized(TestSingeton02.class){//加锁  
4.                 if(null == instance){  
5.                     instance = new TestSingeton02();  
6.                 }  
7.             }  
8.         }  
9.         return instance;  
10.     }  

2）：饿汉式：（一定是安全的，只有一份对象）
1.构造器私有化
2.声明私有的静态属性，同时创建该对象
3.对外提供访问属性的静态方法，确保该对象存在。

(1):写法：初始化就加载

[java] view plain copy 

1. class TestSingeton03 {  
2.     //初始化加载  
3.     private static TestSingeton03 instance = new TestSingeton03();  
4.     private TestSingeton03(){         
5.     }  
6.     public static TestSingeton03 getInstance(){  
7.         return instance;  
8.     }  
9. }  

（2）：写法：类在使用的时候加载，延时加载
[java] view plain copy 

1. class TestSingeton04 {  
2.     //类在使用的时候加载，延时加载  
3.     private static class Single{  
4.         private static TestSingeton04 instance = new TestSingeton04();  
5.     }  
6.     private TestSingeton04(){  
7.     }  
8.     public static TestSingeton04 getInstance(){  
9.         return Single.instance;  
10.     }  
11. }