注释代码，谢谢啊。求教

1. class SingleDemo{
   
2.         private static SingleDemo sd = null;
   
3.         private SingleDemo(){};
   
4.         private Object obj = new Object();
   
5.         public static SingleDemo getSingleDemoObject()
   
6.         {
   
7.              synchronized(obj)
   
8.             {
   
9.                 if(sd==null)
   
10.                 {
    
11.                   sd = new SingleDemo();
    
12.                   return sd;
    
13.                 }
    
14.                 else
    
15.                 {
    
16.                   thorws new RuntimeException("获取失败");
    
17.                 }
    
18.             }
    
19.         }
    
20.         public void Test()
    
21.         {
    
22.                 System.out.println("Test");
    
23.         }
    
24. }
    
25. class Single
    
26. {
    
27.         public static void main(String[] args){
    
28.                 SingleDemo sd = SingleDemo.getSingleDemoObject();
    
29.                 sd.Test();
    
30.         }
    
31. }

复制代码

记事本敲的 不保证没有错误！

即实现，单例模式中的懒汉模式。先给出代码：

public class Lazy {
        private Lazy lazy;
        private Lazy(){       
        }
       
        public Lazy getInstance(){
                if(lazy==null)
                {
                        synchronized (this) {
                                if(lazy==null)
                                        lazy=new Lazy();
                        }
                }
                return lazy;
        }
}
思路：
一，单例设计；
二，解决线程安全问题。

步骤：
一、实现单例三步：
1，私有本类对象属性：private Lazy lazy;
2，私有构造方法：private Lazy(){ }
3,对外暴漏获取实例的功有方法
public Lazy getInstance(){
       if(lazy==null)
             lazy=new Lazy();
       return lazy;       
}
这样基本功能已经完成，若是单线程程序，就ok了。可如果是多线程程序，还有线程安全问题。
二、解决线程安全问题
java中提供了解决线程安全的机制，即同步机制。
实现同步的关键字synchronized ，被该关键字修饰的内容相当于被锁住了，钥匙由当前的使用者保管。
实现同步有两种方式：同步函数、同步代码块。
同步函数，即锁住函数的代码块。
public synchronized Lazy getInstance(){...}

同步代码块，即选择性的锁住相关语句。
synchronized (this) {
        if(lazy==null)
                lazy=new Lazy();
}
同步函数，每次都要判断锁，影响效率。这里选择同步代码块，更为合理。
要体现出同步代码块的这一优势，写成上面的样子，无异于同步函数。所以代码需要进一步优化，用双重判断，减少对锁的判断。

               if(lazy==null)
                {
                        synchronized (this) {
                                if(lazy==null)
                                        lazy=new Lazy();
                        }
                }