1. class Single
   
2. {
   
3.         private static Single s = null;
   
4.         private Single(){}
   
5.         public static  Single getInstance()
   
6.         {
   
7.                 if(s==null)
   
8.                 {
   
9.                         synchronized(Single.class)
   
10.                         {
    
11.                                 if(s==null)//位置一
    
12.                                         s = new Single();
    
13.                         }
    
14.                 }
    
15.                 return s;
    
16.         }
    
17. }

复制代码

去掉位置一的那句判断行不行啊，我觉得好像没什么影响，请教各位了

哥，这个是懒汉式吧，去掉位置一可以，但是加上会更安全。

钟成军 发表于 2014-4-24 11:21
哥，这个是懒汉式吧，去掉位置一可以，但是加上会更安全。

额，谢谢提醒，改过来了，加上为什么更安全呢，我觉得那句判断完全多余啊

视频上有讲解，涉及到多线程、CPU轮转机制，如果没有那一句，就可能会建立两个对象

1. if(s==null) {
   
2.       --A
   
3.       synchronized(Single.class){
   
4.           --B
   
5.               s = new Single();
   
6.       }
   
7. }

复制代码

你看代码，如果没有那一句，虽然B在的时候A无法进来，但是B在new过对象以后，A同样也能进来，这样就建立两个对象，但是这是单例设计模式，只能存在一个对象，所以不符合设计理念。
但是加上if(s==null)就不一样了，B出去了，对象建立了，此时s就已经有值了，所以A进来也不能在创建对象了。

毕老师在视频上详细讲解了，
回头仔细看看吧。

主要就是安全性的问题。

如果不加if(s==null)，就存在安全隐患。比如说线程A和B都经过第一次if(s==null)判断后就跳转到线程C了，线程C没有跳转，直接进去newl了一个对象，然后线程C释放了。又轮到A进去了，这个时候虽然S不等于null了，但是A线程已经在s=null的时候就走完了判断，进入到同步代码区里，如果不再一次判断s是否等于null,A线程就会再new一个对象，同理B也会new一个对象，这样就不能保证对象唯一性了。所以获得锁进入之后也要再次判断。这样的安全隐患是有几率发生的，所以一定要两次判断。

如果没有那句的话，可能就会出现线程安全问题，也就是说可能会出现不止一个对象
class Single
{
private static Single s = null;
private Single(){}
public static Single getInstance()
{
  if(s==null)
  {
   synchronized(Single.class)
   {
   // if(s==null) 如果没有这句话的话，假设线程a先通过外层判断通过之后，然后进入到同步代码块里面，就在这个地方线程a等待了，释放了执行资格，
                          线程b也是先通过了外层判断，通过之后，由于同步代码块要判断锁，没有进去，假设现在线程a醒了，然后就new了一个，然后线程b也就
                          可以进入到同步代码块里面了，由于没有这句话，所以他还会执行s = new Single(); 所以就会出现了两个对象，出现了线程安全问题。


     s = new Single();
   }
  }
  return s;
}
}

☆枫の云 发表于 2014-4-24 11:31
视频上有讲解，涉及到多线程、CPU轮转机制，如果没有那一句，就可能会建立两个对象

你看代码，如果没有那 ...

明白了，没搞清楚外面和里面的if判断的各自作用，还是掌握得不够，思考得太草率了，谢谢了

☆枫の云 发表于 2014-4-24 11:31
视频上有讲解，涉及到多线程、CPU轮转机制，如果没有那一句，就可能会建立两个对象

你看代码，如果没有那 ...

明白了，谢谢前辈，有点费脑子感觉这

1. class Single
   
2. {
   
3.      privtate Single(){};
   
4.      private static Single s=new Single();
   
5.      public static Single getInstance()
   
6.      {
   
7.             if(s==null)
   
8.             {
   
9.                   Synchronized(Single.class)
   
10.                   {
    
11.                          if(s==null)//位置一
    
12.                                       s = new Single();
    
13.                         
    
14. 
    
15. }
    
16. }
    
17. return s;
    
18. 
    
19. }
    
20. }

复制代码

如果去掉位置一的代码，当首先A进入线程并首先创建了对象，跳出了同步代码块，却并没有return s;的时候，B线程可以进来而且可以再次创建一个对象，这样就违背了单例设计模式的基本原则了.