这是毕老师的代码，我就没理解这个多线程下的单例 ，代码也没体现出来啊，那个大哥给解释下，听的云里雾里的
/*
多线程下的单例

*/

//饿汉式
class Single
{
        private static final Single s = new Single();
        private Single(){}
        public static Single getInstance()
        {
                return s;
        }
}



//懒汉式

加入同步为了解决多线程安全问题。

加入双重判断是为了解决效率问题。




class Single
{
        private static Single s = null;

        private Single(){}

        public static Single getInstance()
        {
                if(s==null)
                {
                        synchronized(Single.class)               
                        {
                                if(s==null)
                //                                -->0 -->1
                                        s = new Single();
                        }
                }
                return s;
        }
}
class  SingleDemo
{
        public static void main(String[] args)
        {
                System.out.println("Hello World!");
        }
}

帮你加了注释，应该可以看得懂吧

1. //饿汉式:我一上来就先创建一个对象，你要了就给你，不要就先放着
   
2. class Single
   
3. {
   
4.         //先创建好对象等你来拿
   
5.         private static final Single s = new Single();
   
6.         //所谓单例就是这个对象只能有一个，所以外部不能创建对象
   
7.         //怎么保证外部不能创建对象呢，构造函数私有即可
   
8.         private Single(){}
   
9.         //构造函数私有了，外部也不能创建对象了，那人家怎么用呢，
   
10.         //当然要给人家提供一个获取实例对象的方法了，注意要用静态方法，
    
11.         //因为只有静态方法才可以在没有示例对象的情况下还可以被调用
    
12.         public static Single getInstance()
    
13.         {
    
14.                 return s;
    
15.         }
    
16. }
    
17. 
    
18. //懒汉式：我先不创建对象，等你来要了再创建一个，不要就不创建了，多清闲呀（懒）
    
19. 
    
20. //加入同步为了解决多线程安全问题。
    
21. //加入双重判断是为了解决效率问题。
    
22. class Single2
    
23. {
    
24.         //你来这里就有，准备的有这个东西，但是这个东西我先不创建
    
25.         private static Single2 s = null;
    
26.         //和上面的一样，单例构造方法就要私有
    
27.         private Single2(){}
    
28.         //构造方法私有了，就得提供获取对象的方法给人家
    
29.         public static Single2 getInstance()
    
30.         {
    
31.                 //创建对象前先判断下是否已经有了对象，因为多线程运行时，别的线程可能先创建好了对象
    
32.                 //如果有了就直接拿着对象走人，不要再进去折腾了
    
33.                 if(s==null)
    
34.                 {
    
35.                         //将创建对象的代码放在同步代码块中，使用本类对象的class文件做同步锁，
    
36.                         //保证创建对象时只有一个线程可以在下面的代码块中运行，防止多线程运行时，有可能出现多个对象的问题
    
37.                         synchronized(Single2.class)               
    
38.                         {
    
39.                                 if(s==null)
    
40.                                         s = new Single2();
    
41.                         }
    
42.                 }
    
43.                 return s;       
    
44.         }
    
45. }
    
46. //这个就不必解释了吧
    
47. class  SingleDemo
    
48. {
    
49.         public static void main(String[] args)
    
50.         {
    
51.                 System.out.println("Hello World!");
    
52.         }
    
53. }
    

复制代码

谢谢啊 这么详细。。。。

这利用了锁的机制。synchronized是java语言的关键字，当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。我对毕老师的那节课做了一下总结，如果感兴趣可以看我的这篇总结：http://blog.csdn.net/shengfeixiang/article/details/8567567   希望对你有帮助。