饿汉式，对象在类一进内存时就加载，懒汉式在方法调用时才加载对象，他们在内存中运行的区别是什么？
懒汉式在运行时会出现点问题，突然cpu转向别的程序，A，B，C三个来判断if（s==null），将会出现可能创建多个对象问题，该怎么解决？

饿汉式与懒汉式在内存中的区别：饿汉式一旦被加载进内存便建立自己的本类对象，懒汉式在被加载进内存后先建立一个空的本类引用，在调用其方法时再进行判断，若引用为空则建立对象并返回，若不为空则直接返回。
懒汉式在多线程技术中会出现不同步问题，就需要用到synchronized进行同步。

用synchronized()加锁

1：它们在内存运行区别是饿汉式类一加载对象就存在内存中了，懒汉式是我创建一个一个静态变量，变量已经存在但没有值只有调用getIntance时对象才存在内存中。
2：要解决你的第二个问题就要用到synchronized()同步了，因为懒汉式是多线程并发访问的，所以出现不同步问题

1. /*它们之间的区别上面的同学已经和你说明了我就不再赘述了
   
2. *我着重对懒汉式在避免线程安全问题上进行说明
   
3. */
   
4. public class Single {
   
5. 
   
6.         private Single() {
   
7. 
   
8.         }
   
9. 
   
10.         private static Single s = null;
    
11. 
    
12.         public static Single getInstance() {
    
13.                 // -->line B
    
14.                 if (s == null) { // -->line A
    
15.                         s = new Single();
    
16.                 }
    
17.                 return s;
    
18.         }
    
19. }
    
20. 
    
21. /*
    
22. * 1,两个线程并发调用函数getInstance()，lineA判断s为null,然后向下执行
    
23. * 2,这时JVM将CPU切换到lineB,由于lineA还未执行创建对象语句，所以s依然为null
    
24. * 3,lineB执行了new Single()语句后，lineA被重新唤醒，也执行了new Single()语句
    
25. * 4,单例设计模式此时创建出两个对象，问题就这样产生了
    
26. * 如何解决呢？代码如下：
    
27. */
    
28. public class Single {
    
29.         private Single() {
    
30. 
    
31.         }
    
32. 
    
33.         private static Single s = null;
    
34. 
    
35.         public synchronized static Single getInstance() {
    
36.                 if (s == null) {
    
37.                         s = new Single();
    
38.                 }
    
39.         }
    
40. }
    
41. 
    
42. /*
    
43. * 在方法中加入同步修饰符，线程的安全问题得到解决，但代码的性能被大大降低了
    
44. * 除了第一次调用getInstance()时执行了Single的构造函数外，以后每次调用都是返回s对象
    
45. * 返回对象耗时很小，但每次判断同步就恰恰相反了
    
46. * 如何优化这段代码的性能问题呢？代码如下：
    
47. */
    
48. public class Single {
    
49.         private Single() {
    
50. 
    
51.         }
    
52. 
    
53.         private static Single s = null;
    
54. 
    
55.         public static Single getInstance() {
    
56.                 synchronized (Single.class) {
    
57.                         if (s == null) {
    
58.                                 s = new Single();
    
59.                         }
    
60.                 }
    
61.         }
    
62. }
    
63. 
    
64. /*
    
65. * 不难发现，将同步写为代码块的形式之后，每次调用getInstance()都需要对其进行判断
    
66. * 由于只需第一次创建s时进行同步，所以可以修改为下面的写法:
    
67. */
    
68. public class Single {
    
69.         private Single() {
    
70. 
    
71.         }
    
72. 
    
73.         private static Single s = null;
    
74. 
    
75.         public static Single getInstance() {
    
76.                 if (s == null) {
    
77.                         synchronized (Single.class) {
    
78.                                 if (s == null) {
    
79.                                         s = new Single();
    
80.                                 }
    
81.                         }
    
82.                 }
    
83.         }
    
84. }
    
85. /*
    
86. * 修改至此，只能保证代码的性能问题得到部分解决，其实这样使用单例设计模式依然存在问题
    
87. * 所以我们得到了最终的解决方案，代码如下:
    
88. */
    
89. public class Single {
    
90.         private Single() {
    
91. 
    
92.         }
    
93. 
    
94.         private static Single s = new Single();
    
95. 
    
96.         public static Single getInstance() {
    
97.                 return s;
    
98.         }
    
99. }
    
100. /*
     
101. * 我曾经上网查找过相关资料
     
102. * 关于懒汉式单例设计模式提到了计算机CPU的执行顺序是乱序的，所以依然可能在运行中报错
     
103. * 具体为什么还会出现问题至今我还是不太理解，所以我不敢在这里卖弄
     
104. * 你只需知道在写单例设计模式的时候用饿汉式就可以
     
105. * 希望这样一个对代码的说明加修改过程对你理解懒汉式单例涉及模式有帮助
     
106. */

复制代码

区别：
饿汉式：先初始化对象，Single类一进内存，就创建对象。
懒汉式：对象方法被调用时，才初始化，也叫做对象的延时加载。Single类进内存，对象还没有存在，只有调用了getInstance方法时，才建立对象。
运用同步锁 ，去锁定不安全的代码。
这样可以避免出现CUP跳转后发生的异常现象。

懒汉式与饿汉式都是单例模式，目的是限制随意建立对象，两者的区别，在于：
1.饿汉式随着类的加载建立对象，而懒汉式则是在调用时才建立对象，按照毕老师的说法，相对饿汉式，懒汉能节约少许内存
2.但懒汉式有一个硬伤就是你所说到的多线程cpu跳转问题，针对这个问题的解决方案就是加锁进行同步处理，具体请参考毕老师多线程教学视频
PS：两者各有优劣，不过据几个搞开发的朋友说他们喜欢的是饿汉式，当然，你要是运存控的话，用懒汉也是不错选择

毕老师的视频里有讲到，synchronized锁来解决，面试中可能会遇到，实际开发中用不到。