懒汉式单例设计模式中都有哪些可以问题可以被问到，求高手总结一下

他和饿汉式有什么区别？
两种方案的构造函数和公用方法都是静态的（static），实例和公用方法又都是私有的（private）。但是饿汉式每次调用的时候不用做创建，直接返回已经创建好的实例。这样虽然节省了时间，但是却占用了空间，实例本身为static的，会一直在内存中带着。懒汉式则是判断，在用的时候才加载，会影响程序的速度。最关键的是，在并发的情况下，懒汉式是不安全的。如果两个线程，我们称它们为线程1和线程2，在同一时间调用getInstance()方法，如果线程1先进入if块，然后线程2进行控制，那么就会有两个实例被创建。

据毕老师视频上来说，懒汉式的问题主要在其的不安全性，可以参考下

写法一：初始化对象——饿汉式

class Single

{

private static 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)

s = new Single ();

return s;

}

}

饿汉式特点：Single类一进内存，就已经创建好了对象。

懒汉式特点：Single类进内存，对象还没存在，只有调用了getInstance方法时，才建立对象。

开发时一般使用饿汉式方法，因为比较安全。

对于懒汉式可以用public static synchronized(同步，锁) Single getInstance ，不过效率会因而减慢。

可以继续改进为：

public static Single getInstance()

{

if (s == null)

{

synchronized(Single.class)

{

if (n == null)

s = new Single();

}

}

return s;

}

原则：定义单例，建议使用饿汉式。

以下是我看毕老师视频后自己整理的笔记，或许对你有用。
单例设计模式-----饿汉式、懒汉式  （背也要背下来）
        目的：保证Java虚拟机中一个类的对象始终只有一个，可以节省内存的开销
        单例设计模式要领：
                1.构造方法私有化
                2.对外提供一个公开的静态的获取当前类型对象的构造方法
                3.提供一个当前类型的私有的静态变量
        缺点：单例模式的类型不能被继承，不可能有子类
        饿汉式：class Single
                      {
                                private static 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)
                                         {
                                                 s = new Single();
                                         }
                                         return s;
                                }
                      }
        饿汉式与懒汉式的区别：懒汉式的特点是实例延迟加载，在有多线程访问时存在安全问题,可以加同步来解决，用双重判断可以解决效率低的问题
        对懒汉式的扩展：               
                class Single
                {
                        private static Single s = null;
                        private Single()
                        {}                                                                        
                        public static Single getInstance()
                        {
                                //用双重判断来提高懒汉式的效率
                                if (s == null)
                                {
                                        synchronized(Single.class)  //锁是本类对应的字节码文件对象
                                        {
                                                if (s == null)
                                                        s = new Single();
                                        }
                                }
                                return s;
                        }
                }

这是我的总结，你看看能否帮到你
1.私有本类构造方法，通过static 方法geiInstance()获取实例对象
2.成员变量；本类引用初始化为null，
3.在需要同步的代码上加锁。（废话）
4.优化同步锁（if(s==null)）

1. class Single
   
2. {
   
3.         private static Single s=NULL;
   
4.         private Single(){}                //单例，不能在本类外newSingled对象。Single s=new Single（）；
   
5.         public static Single getInstance()   //获取实例的方法。即建立对象的方法。
   
6.         {
   
7.                 if(s==NULL) //这是为了减少判断synchronized，提高效率。
   
8.                 {
   
9.                         synchronized(Single.class)//找到唯一对象当锁
   
10.                         {
    
11.                                 if(s==NULL)
    
12.                                         s=new Single();
    
13.                         }
    
14.                 }
    
15.                 return s;
    
16.         }
    
17. }
    
18. 
    
19. 懒汉式的特点在于实例的延迟加载
    
20. 
    
21. 饿汉式：
    
22. class Single
    
23. {
    
24. 　　private static final Single s = new Single();
    
25. 　　private Single(){};
    
26. 　　public static Single getInstance()
    
27. 　　{
    
28. 　　return s;
    
29. 　　}
    
30. }

复制代码

饿汉式:
        public class Singleton{
            private static Singleton singleton = new Singleton ();
            private Singleton (){}
            public Singleton getInstance(){return singletion;}
       }

     懒汉式:
       public class Singleton{
            private static Singleton singleton = null;
            public static synchronized synchronized getInstance(){
                 if(singleton==null){
                     singleton = new Singleton();
                 }
                return singleton;
            }
       }

     比较:
         饿汉式是线程安全的,在类创建的同时就已经创建好一个静态的对象供系统使用,以后不在改变
          懒汉式如果在创建实例对象时不加上synchronized则会导致对对象的访问不是线程安全的
          推荐使用第一种

单例设计模式：解决一个类在内存中只存在一个对象。

想要保证对象唯一
1，为了避免其他程序过多建立该类对象。先禁止其他程序建立该对象
2，还为了让其他程序访问到该对象，只好在本类中自定义一个对象
3，为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式。

这三步怎么用代码体现？
1，将构造函数私有化
2，在类中创建一个本类对象
3，提供一个方法可以获取该对象

对于事物该怎么描述，还怎么描述
当需要该事物的对象保证在内存中唯一时，就将以上的三步加上即可

单例有两种表现形式：

饿汉式：

1. class Single{
   
2.         //构造函数私有化，使外部不能建立对象
   
3.         private Single(){}
   
4.         //内部建立一个对象，只能由类调用，必须是静态的
   
5.         private static Single s = new Single();
   
6.         //定义一个获取实例的方法提供给外部
   
7.         public static single getInsatnce(){
   
8.                 return s;
   
9.         }
   
10. }

复制代码

懒汉式：

1. class Single{
   
2.         private Single(){}
   
3.         private static single s = null;
   
4.         public static Single getInsatnce(){
   
5.                 if(s==null){
   
6.                         synchronized(Single.class){
   
7.                                 if(s==null)
   
8.                                         s = new Single();
   
9.                         }
   
10.                 }
    
11.                 return s;
    
12.         }
    
13. }

复制代码

懒汉式有什么特点：
懒汉式的特点在于延迟加载，延迟加载会引发安全问题，在线程切换时可能创建多个对象，使用同步可以解决这个问题，同步中使用的锁是类的字节码，即Single.class，但同步会造成效率降低，所以在获取实例的时候使用了双重判断，使效率提高

在实际应用中要使用饿汉式