1. 单例设计模式
   
2. （1）饿汉式
   
3. class Single
   
4. {
   
5.            private static final Single s = new Single();
   
6.            private Sinle(){｝
   
7.            public static Single getInstance()
   
8.            {
   
9.                    return s;
   
10.            }
    
11. }（2）懒汉式
    
12. class Single
    
13. {
    
14.             private static Single s = new Single();
    
15.             private Single(){}
    
16.             public static Single getInstance()
    
17.             {
    
18.                       if(s==null)//这里判断为空的话，就会去检测锁，每次只能进去一个。
    
19.                       {
    
20.                                 Synchronized(Single.class)
    
21.                                  {
    
22.                                          if(s==null)//这里有必要判断为空吗？能进来锁，就代表他是来创建对象的，何必再判断
    
23.                                          Single s = new Sinle();
    
24.                                   }
    
25.                       }
    
26.                       return s;
    
27.              }
    
28. }

复制代码

1.    if(s==null)//这一行是用来对象创建好之后，不用再执行判断锁的作用，因为判断锁的操作比较麻烦，至少比if语句麻烦
   
2.                       {-A -B //假设俩个线程都正好到了这里
   
3.                                 Synchronized(Single.class)
   
4.                                  {
   
5. //if(s==null)//如果这一行去掉，A先进来 创建完对象出去了，B再进来又创建对象，这不是就创建两个对象了，所以这一行不能省
   
6.                                          Single s = new Sinle();
   
7.                                   }
   
8.                       }
   
9.                       return s

复制代码

1.                   if(s==null)
   
2.                       {                   //1,2两个线程都走了到这里，1线程进去了，2线程等待1线程释放锁
   
3.                                 Synchronized(Single.class)
   
4.                                  {
   
5.                                          //1线程释放锁，2线程进来了，如果不判断s==null，就会再创建一个对象
   
6.                                          //如果！=null。就不创建
   
7.                                          if(s==null)
   
8.                                          Single s = new Sinle();
   
9.                                   }
   
10.                       }

复制代码

1. （2）懒汉式:延迟加载方式
   
2. class Single
   
3. {
   
4.             //private static Single s = new Single();
   
5.             private static Single s = null;//此处不实例化
   
6.             private Single(){}
   
7.             public static Single getInstance()
   
8.             {
   
9.                       if(s==null)//这里判断为空的话，就会去检测锁，每次只能进去一个。
   
10.                       {
    
11.                                 Synchronized(Single.class)
    
12.                                  {
    
13.                                            //这里肯定要判断啊，如果线程a执行完此处的代码块，在a执行的过程中线程b已经经过第一次判断，
    
14.                                            //到了Synchronized代码块之前，那么等b拿到锁就会进来这里，如果不判断s是否为空，就会第二次实例化了
    
15.                                           //这样就不是单例了~~
    
16.                                          if(s==null)//这里有必要判断为空吗？能进来锁，就代表他是来创建对象的，何必再判断
    
17.                                          Single s = new Sinle();
    
18.                                   }
    
19.                       }
    
20.                       return s;
    
21.              }
    
22. }

复制代码

是这么回事。

楼上正解！

进来学习