1. package cn.itheima;
   
2. /*
   
3.         单例设计模式：解决一个类在内存中只存在一个对象
   
4.         体现方式：
   
5.                 1. 构造函数私有化
   
6.                 2. 在类中创建一个本类对象
   
7.                 3. 提供一个方法获取该对象
   
8. 
   
9. */
   
10. 
    
11. //饿汉式：先初始化对象，类一进内存就创建好了对象
    
12. class HungrySingleton{
    
13.        
    
14.         private static final HungrySingleton s = new HungrySingleton();
    
15.         private HungrySingleton(){}
    
16.        
    
17.         public static HungrySingleton getInstance(){
    
18.                
    
19.                 return s;
    
20.         }
    
21. }
    
22. 
    
23. /*
    
24. 懒汉式：对象是方法被调用时才初始化，也叫做对象的延迟加载
    
25. 懒汉式考点：
    
26.         1. Q:懒汉式和饿汉式有什么不同                A:懒汉式的特点在于实例延迟加载
    
27.         2. Q:懒汉式延迟加载有什么问题                A:如果多线程访问会出现安全问题
    
28.         3. Q:安全问题怎么解决                                A:加同步代码块或同步函数解决，但有可能程序低效，可以采用双重判断解决效率问题
    
29.         4. Q:加同步使用的锁是哪一个                        A:该类所属的字节码文件对象，LazySingleton.class
    
30. */
    
31. class LazySingleton{
    
32.        
    
33.         private static LazySingleton s = null;
    
34.         private LazySingleton(){}
    
35.        
    
36.         public static LazySingleton getInstance(){
    
37.                
    
38.                 if (s==null){
    
39.                        
    
40.                         synchronized(LazySingleton.class){
    
41.                                
    
42.                                 if (s==null){
    
43.                                        
    
44.                                         s = new LazySingleton();
    
45.                                 }
    
46.                         }
    
47.                 }
    
48.                
    
49.                 return s;
    
50.         }
    
51. }
    
52. 
    
53. 
    
54. class SingletonDemo{
    
55.        
    
56.         public static void main(String[] args){
    
57.                
    
58.                 HungrySingleton s = HungrySingleton.getInstance();
    
59.                 HungrySingleton s1 = HungrySingleton.getInstance();
    
60.                
    
61.                 LazySingleton s3 = LazySingleton.getInstance();
    
62.                 LazySingleton s4 = LazySingleton.getInstance();
    
63.                
    
64.                 System.out.println(s==s1);
    
65.                 System.out.println(s3==s4);
    
66.         }
    
67. }
    

复制代码

学习学习.

chengzhx76 发表于 2014-8-13 13:14
有次面试让手写单例模式。。。最好还是要理解，如 为什么要用单例模式，单例模式的好处。。等等。。。 ...

嗯，必须要理解。学习过程中记录的学习笔记

有次面试让手写单例模式。。。最好还是要理解，如 为什么要用单例模式，单例模式的好处。。等等。。。

线程中 比较实用吧

学习笔记。。。