问题在代码 写清楚了,,大神给看一下解释一下吧
Single.java

1. package com.xiaobei.test;
   
2. 
   
3. /*
   
4. * 单例  :懒汉模式
   
5. *                 高效的懒汉模式 实例
   
6. * 疑问:  
   
7. *                 为什么 再 synchronous之后   那个if(s==null) 不能去掉
   
8. *                 老师给我们解释说,在sychronous(Single.class)  会出现卡住现象
   
9. *                 从而会又new Single.....但是我理解的  
   
10. *                 sychronous()的功能不就是,防止 卡住一类的现象,实现 同步吗???
    
11. *                 那要是这里能卡住,,,那其他同步应用 synchronous的 时候 ,是不是也会卡住,是不是也需要在其后面加个判断哪????/
    
12. *                 希望  大神 给解释一下/////////////
    
13. */
    
14. public class Single {
    
15.         private Single() {
    
16.         }
    
17. 
    
18.         Single s = null;
    
19. 
    
20.         public Single getInstance() {
    
21.                 if (s == null) {
    
22.                         synchronized (Single.class) {//老师给我们解释说 这里或在  取 Single.class的时候会卡住,
    
23.                                 if (s == null) {//大神(最好是老师哈)给解释一下为什么这个if不能去掉吗
    
24.                                         s = new Single();
    
25.                                 }
    
26.                         }
    
27.                 }
    
28.                 return s;
    
29.         }
    
30. }
    

复制代码

SingleDemo.java

1. package com.xiaobei.test;
   
2. /*
   
3. * 测试单例模式,懒汉式
   
4. */
   
5. class SingleRunnable implements Runnable{
   
6. 
   
7.         @Override
   
8.        
   
9.         public void run() {
   
10.                 // TODO Auto-generated method stub
    
11.                 for (int i = 0; i < 20; i++) {
    
12.                         Single s=Single.getInstance();
    
13.                         System.out.println(s);
    
14.                 }
    
15.         }
    
16.        
    
17. }
    
18. public class SingleDemo {
    
19.         public static void main(String[] args) {
    
20.                 SingleRunnable s=new SingleRunnable();
    
21.                 Thread t0=new Thread(s);
    
22.                 Thread t1=new Thread(s);
    
23.        
    
24.                 t0.start();
    
25.                 t1.start();
    
26.                
    
27.         }
    
28. }
    

复制代码

大家帮忙给解释一下啊

懒汉单例 是拿内存换时间, 提升效率.叫懒汉的原因是if那个判断, 也就是有需求才去创建没的话就继续偷懒

还没看到这个知识点

你的问题应该是，if(s==null){s=new Single();} 这句话会卡住，因为在做if判断时，一个线程停在这里，另一个线程又进来了，导致两个线程都是true，都创建对象，那就不是单例了。

1. public Single getInstance() {
   
2.                 if (s == null) {
   
3.                         // 第一次，s=null，t1 t2线程执行到这里
   
4.                         synchronized (Single.class) {
   
5.                                 //t1拿到锁，进来。创建完对象，出去
   
6.                                 //t2拿到锁，进来。发现s != null，直接出去。        如果没有这一层判断，会再建一个对象
   
7.                                 if (s == null) {
   
8.                                         s = new Single();
   
9.                                 }
   
10.                         }
    
11.                 }
    
12.                 return s;
    
13.         }

复制代码

需要学习下，不太懂

Hi.。 发表于 2015-12-18 12:11

嗯嗯   我觉得你解释很对啊，，，这样可以解释通了，，，当时老师给我们说  在synchronized那卡住，，，怎么想也想不通  谢谢啦

只定义，用到再new