您的位置：首页 > 其它

使用静态内部类实现单例设计模式

2017-08-19 19:08 302 查看
         前几天看了下公司代码中的一个单例类，发现居然是用静态内部类实现的。后面在网上找了下资料，发现使用静态内部实现的单例是懒加载的且线程安全。
         从网上资料得出如下结论：加载一个类时，其内部类不会同时被加载。一个类被加载，当且仅当其某个静态成员（静态域、构造器、静态方法等）被调用时发生。

一、代码

package com.zxy.test;
/**
* 使用静态内部类实现的单例类
* @author  ZENG.XIAO.YAN
* @date2017-08-08 10:29:20
* @version  V1.0
*/

public class UserSingleton {

/** 私有化构造器*/
private UserSingleton() {
}

/** 对外提供公共的访问方法*/
public static UserSingleton getInstance() {
return UserSingletonHolder.INSTANCE;
}

/** 写一个静态内部类，里面实例化外部类*/
private static class UserSingletonHolder {
private static final UserSingleton INSTANCE = new UserSingleton();
}

}
26 1
package com.zxy.test;
2
/**    
3
* 使用静态内部类实现的单例类
4
* @author  ZENG.XIAO.YAN   
5
* @date    2017-08-08 10:29:20
6
* @version  V1.0   
7
*/
8
9
public class UserSingleton {
10
   
11
   /** 私有化构造器*/
12
   private UserSingleton() {
13
   }
14
15
   /** 对外提供公共的访问方法*/
16
   public static UserSingleton getInstance() {
17
      return UserSingletonHolder.INSTANCE;
18
   }
19
20
   
21
   /** 写一个静态内部类，里面实例化外部类*/
22
   private static class UserSingletonHolder {
23
      private static final UserSingleton INSTANCE = new UserSingleton();
24
   }
25
26
}
package com.zxy.test;
/**
* 使用静态内部类实现的单例类
* @author  ZENG.XIAO.YAN
* @date2017-08-08 10:29:20
* @version  V1.0
*/
public class UserSingleton {

/** 私有化构造器*/
private UserSingleton() {
}

/** 对外提供公共的访问方法*/
public static UserSingleton getInstance() {
return UserSingletonHolder.INSTANCE;
}

/** 写一个静态内部类，里面实例化外部类*/
private static class UserSingletonHolder {
private static final UserSingleton INSTANCE = new UserSingleton();
}

}
x 1
package com.zxy.test;
2
/**    
3
* 使用静态内部类实现的单例类
4
* @author  ZENG.XIAO.YAN   
5
* @date    2017-08-08 10:29:20
6
* @version  V1.0   
7
*/
8
public class UserSingleton {
9
10
/** 私有化构造器*/
11
   private UserSingleton() {
12
   }
13
14
   /** 对外提供公共的访问方法*/
15
   public static UserSingleton getInstance() {
16
      return UserSingletonHolder.INSTANCE;
17
   }
18
   
19
   /** 写一个静态内部类，里面实例化外部类*/
20
   private static class UserSingletonHolder {
21
      private static final UserSingleton INSTANCE = new UserSingleton();
22
   }
23
24
}
二、小结
      （1）为什么这样实现就是单例的？             因为这个类的实例化是靠静态内部类的静态常量实例化的。             INSTANCE 是常量，因此只能赋值一次；它还是静态的，因此随着内部类一起加载。
      （2）这样实现有什么好处？
              我记得以前接触的懒汉式的代码好像有线程安全问题，需要加同步锁才能解决。
              采用静态内部类实现的代码也是懒加载的，只有第一次使用这个单例的实例的时候才加载；
              同时不会有线程安全问题
      （3）参考文档
                    http://yongliang567.iteye.com/blog/904467 

                                            

                                        

                        
                        内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 点击这里给我发消息 
                    

                    

                    

                        

                         标签： 
                                                

                        

                    


                

            


            

                
相关文章推荐

                

                
            

        

        

            

            
            

                

                    
新的分享

                    

                        
                    

                

            


            

                

                    
章节导航