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

复制代码

顾名思义，延迟加载就是对象延迟加载到内存中
可是堆的空间很大的自由存储空间
一个对象能占多大空间呢？
搞这样一个模式的作用仅仅是优化内存吗？
很怀疑有没有别的作用？

只有一个作用，就是第一次获取对象的时候，才创建该类的对象(饿汉式是类加载的时候创建)，之所以用同步是为了多线程使用的时候，线程安全。双重判断是为了避免每次都去判断锁，以为判断锁比较低效。所以说推荐用饿汉式单例设计模式，简单，没有线程安全问题。单例设计模式的作用是保证整个系统中该类的对象只有一个。保证系统中该类对象只有一个可不是为了省内存，是为了设计需要，比如现实生活中的某些系统，某种东西只有一个。

单例设计模式的作用并不是为了优化内存。
而是保证一个类在内存中的对象的唯一性。如软件的配置文件，可以使用单例，保证配置文件只有一份。

之所以用到了同步，是因为在多线程中懒汉式即延迟加载会出每现安全问题。
双重判断是为了避免每次都去判断锁，每次判断锁比较低效。

懒汉式在开发中用的不多，一般用饿汉式，懒汉式多见于面试中。

1. /*饿汉式
   
2. class Single
   
3. {
   
4.        
   
5.         private static final Single s = new Single();
   
6.         private Single(){}
   
7.         public static Single getInstance()
   
8.         {
   
9.                 return s;
   
10.         }
    
11. }
    
12. */
    

复制代码

哥几个说的我都懂
我问的是对象延迟加载到底有什么好处呢?
我怀疑延迟不仅仅是为了优化内存

dicegame 发表于 2013-7-29 00:02
哥几个说的我都懂
我问的是对象延迟加载到底有什么好处呢?
我怀疑延迟不仅仅是为了优化内存 ...

这还有什么怀疑的。。。。