单态设计模式中饱汉形式和饥汉形式之间有什么不同？有必要区分这两形式吗？本人认为区分这两种形式没必要，都是不管调用多少次getInstance方法，返回的都是同一个实例对象。如果要区分，那么这两种形式各有什么好处？
[ 本帖最后由 蔡园园 于 2011-08-11  01:20 编辑 ]

不用怀疑，肯定有必要

（1）懒汉式实现，示例代码如下：

Java代码   
1./**   
2. * 懒汉式单例实现的示例   
3. */   
4.public class Singleton {   
5. /**   
6. * 定义一个变量来存储创建好的类实例   
7. */   
8. private static Singleton uniqueInstance = null;   
9. /**   
10. * 私有化构造方法，好在内部控制创建实例的数目   
11. */   
12. private Singleton(){   
13. //   
14. }   
15. /**   
16. * 定义一个方法来为客户端提供类实例   
17. * @return 一个Singleton的实例   
18. */   
19. public static synchronized Singleton getInstance(){   
20. //判断存储实例的变量是否有值   
21. if(uniqueInstance == null){   
22. //如果没有，就创建一个类实例，并把值赋值给存储类实例的变量   
23. uniqueInstance = new Singleton();   
24. }   
25. //如果有值，那就直接使用   
26. return uniqueInstance;   
27. }   
28. /**   
29. * 示意方法，单例可以有自己的操作   
30. */   
31. public void singletonOperation(){   
32. //功能处理   
33. }   
34. /**   
35. * 示意属性，单例可以有自己的属性   
36. */   
37. private String singletonData;   
38. /**   
39. * 示意方法，让外部通过这些方法来访问属性的值   
40. * @return 属性的值   
41. */   
42. public String getSingletonData(){   
43. return singletonData;   
44. }   
45.}   
/**
* 懒汉式单例实现的示例
*/
public class Singleton {
/**
* 定义一个变量来存储创建好的类实例
*/
private static Singleton uniqueInstance = null;
/**
* 私有化构造方法，好在内部控制创建实例的数目
*/
private Singleton(){
//
}
/**
* 定义一个方法来为客户端提供类实例
* @return 一个Singleton的实例
*/
public static synchronized Singleton getInstance(){
//判断存储实例的变量是否有值
if(uniqueInstance == null){
//如果没有，就创建一个类实例，并把值赋值给存储类实例的变量
uniqueInstance = new Singleton();
}
//如果有值，那就直接使用
return uniqueInstance;
}
/**
* 示意方法，单例可以有自己的操作
*/
public void singletonOperation(){
//功能处理
}
/**
* 示意属性，单例可以有自己的属性
*/
private String singletonData;
/**
* 示意方法，让外部通过这些方法来访问属性的值
* @return 属性的值
*/
public String getSingletonData(){
return singletonData;
}
}


（2）饿汉式实现，示例代码如下：

Java代码   
1./**   
2. * 饿汉式单例实现的示例   
3. */   
4.public class Singleton {   
5. /**   
6. * 定义一个变量来存储创建好的类实例，直接在这里创建类实例，只会创建一次   
7. */   
8. private static Singleton uniqueInstance = new Singleton();   
9. /**   
10. * 私有化构造方法，好在内部控制创建实例的数目   
11. */   
12. private Singleton(){   
13. //   
14. }   
15. /**   
16. * 定义一个方法来为客户端提供类实例   
17. * @return 一个Singleton的实例   
18. */   
19. public static Singleton getInstance(){   
20. //直接使用已经创建好的实例   
21. return uniqueInstance;   
22. }   
23.   
24. /**   
25. * 示意方法，单例可以有自己的操作   
26. */   
27. public void singletonOperation(){   
28. //功能处理   
29. }   
30. /**   
31. * 示意属性，单例可以有自己的属性   
32. */   
33. private String singletonData;   
34. /**   
35. * 示意方法，让外部通过这些方法来访问属性的值   
36. * @return 属性的值   
37. */   
38. public String getSingletonData(){   
39. return singletonData;   
40. }   
41.}   
/**
* 饿汉式单例实现的示例
*/
public class Singleton {
/**
* 定义一个变量来存储创建好的类实例，直接在这里创建类实例，只会创建一次
*/
private static Singleton uniqueInstance = new Singleton();
/**
* 私有化构造方法，好在内部控制创建实例的数目
*/
private Singleton(){
//
}
/**
* 定义一个方法来为客户端提供类实例
* @return 一个Singleton的实例
*/
public static Singleton getInstance(){
//直接使用已经创建好的实例
return uniqueInstance;
}

/**
* 示意方法，单例可以有自己的操作
*/
public void singletonOperation(){
//功能处理
}
/**
* 示意属性，单例可以有自己的属性
*/
private String singletonData;
/**
* 示意方法，让外部通过这些方法来访问属性的值
* @return 属性的值
*/
public String getSingletonData(){
return singletonData;
}
}

饥汉形式代码比较简洁，且效率高