月度归档：2011年06月

让用户可以扩展属性的应用设计

发表评论

在我们的一些应用中，我们可能不能完全设想到用户需要什么样的属性。比如给你一个用户个人信息记录页面，你可能能想到常用的信息，比如

 
用户名 xxxxx
邮箱 xxxx@xxxxx.com
电话 13xxxxxxxxx

但后来用户发现，他可能想记录下自己工作的地址，这样可以方便别人找到自己，那怎么办呢？我们系统开始没有设计这个属性呢。这时候，我们就需要一种方案来轻松的让用户扩展属性。目前gmail的联系人里面就有这个功能。我们的扩展不能去修改原来的表结构，那样不安全，而且由于每个人的需求不一样，很难做到满足大众的个性化需求。这样，我们可以设计一个表来专门支持属性扩展。

我们设计的表 结构如下，（oracle）


create table C_Dic
(
   /* 主键 */
   id                   Integer                        not null,
   /* 表名 */
   tableName            varchar2(50)                   null,
   /* 所扩展表的主键，可以两种格式存储，json和索引算法。
      json 格式简单，易读，但查询效率较低，索引算法生成的串不可读
，
    但效率较高。 比如， md5(table+ k1 + k2)
   */
   "key"                varchar2(254)                  null,
   /* 所扩展表最原始的可以值。json格式。 */
   keys                 varchar2(254)                  null,
   /* 扩展的属性名, 用来取得数据， 以备可能的查询使用。 */
   fieldName            varchar2(64)                   null,
   /* 扩展的属性的现实名称。用来向用户显示。 */
   disName              varchar2(64)                   null,
   /* 属性值 */
   value                varchar2(1024)                 null,
   created              Date                           null,
   modifiled            Date                           null,
   constraint PK_C_DIC primary key clustered (id)
);

其中要特别注意， key 属性用来存储的是一个 根据表名、主键值生成的一个字符串，这样可以简化在字典表中的记录，但不易于读取，所以我们用keys属性来存储可读的主键值， 采用json格式存储。

下面我们来看一个例子， 扩展用户(c_user)的地址和角色资源(c_role_res)的创建者，

这样就完成了属性扩展工作了。那么我们该怎样获取扩展的属性呢？ 很简单 ， 先计算 md5(table_name + k1 + k2), 的值 ，

比如用户表c_user就计算 md5(‘c_user’ + 1),  这样就的到一个值， 然后 通过


select fieldName, disName, value from C_Dic where

tableName='c_user' and key = '计算的md5值'

来获取给这条记录扩展的属性属性值。

至此。基本就完成了这个可扩展属性的设计工作。

作者：http://idocbox.com

java内存泄漏的若干情形

发表评论

        用java编写的程序存在内存泄露吗？ 大家可能认为JVM(java虚拟机)有良好的垃圾回收机制(GC), 不想C/C++那样需要手动回收内存。然而事实是，JVM也是基于一些算法来进行的，在满足一定条件下才能回收内存。

所以，一旦一个内存不能使用需要回收，但却不满足JVM 垃圾回收算法的条件时，那块内存就无法被GC回收，这时就会产生内存泄露。

        为了讲解java内存泄露的几种情形，我们需要简单的介绍一下JVM垃圾回收器的回收算法。所谓垃圾回收，就是查找那些分配的、但没有任何对象指向（引用）的内存。举个简单的例子，

  public void f(){ String str = new String(); }

        那么，当调用完函数f()后，函数内部对象str不会被任何别的对象引用，此时垃圾回收器就会回收str指向的空间。这就是最简单的情形。对于一个java程序，在运行时，先会由JVM的加载进来，内部个对象也在创建、运行过程中会相互引用，从而形成一个复杂的引用关系图。GC就会一直检测这张图中的个对象，一旦发现某个对象没有任何其它对象指向它，GC就会试着去回收它的内存空间。基于这个原理，jvm中常用的回收算法主要有：

       1. 引用计数法
       引用计数法是唯一没有使用根集的垃圾回收的法，该算法使用引用计数器来区分存活对象和不再使用的对象。一般来说，堆中的每个对象对应一个引用计数器。当每一次创建一个对象并赋给一个变量时，引用计数器置为1。当对象被赋给任意变量时，引用计数器每次加1当对象出了作用域后(该对象丢弃不再使用)，引用计数器减1，一旦引用计数器为0，对象就满足了垃圾收集的条件。 
基于引用计数器的垃圾收集器运行较快，不会长时间中断程序执行，适宜地必须 实时运行的程序。但引用计数器增加了程序执行的开销，因为每次对象赋给新的变量，计数器加1，而每次现有对象出了作用域生，计数器减1。 

　　2. tracing算法
         tracing算法是为了解决引用计数法的问题而提出，它使用了根集的概念。基于tracing算法的垃圾收集器从根集开始扫描，识别出哪些对象可达，哪些对象不可达，并用某种方式标记可达对象，例如对每个可达对象设置一个或多个位。在扫描识别过程中，基于tracing算法的垃圾收集也称为标记和清除(mark-and-sweep)垃圾收集器. 

        3. compacting算法
        为了解决堆碎片问题，基于tracing的垃圾回收吸收了Compacting算法的思想，在清除的过程中，算法将所有的对象移到堆的一端，堆的另一端就变成了一个相邻的空闲内存区，收集器会对它移动的所有对象的所有引用进行更新，使得这些引用在新的位置能识别原来 的对象。在基于Compacting算法的收集器的实现中，一般增加句柄和句柄表。

      4. copying算法
       该算法的提出是为了克服句柄的开销和解决堆碎片的垃圾回收。它开始时把堆分成 一个对象 面和多个空闲面， 程序从对象面为对象分配空间，当对象满了，基于coping算法的垃圾 收集就从根集中扫描活动对象，并将每个 活动对象复制到空闲面(使得活动对象所占的内存之间没有空闲洞)，这样空闲面变成了对象面，原来的对象面变成了空闲面，程序会在新的对象面中分配内存。 
一种典型的基于coping算法的垃圾回收是stop-and-copy算法，它将堆分成对象面和空闲区域面，在对象面与空闲区域面的切换过程中，程序暂停执行。 

     5. generation算法
       stop-and-copy垃圾收集器的一个缺陷是收集器必须复制所有的活动对象，这增加了程序等待时间，这是coping算法低效的原因。在程序设计中有这样的规律：多数对象存在的时间比较短，少数的存在时间比较长。因此，generation算法将堆分成两个或多个，每个子堆作为对象的一代(generation)。由于多数对象存在的时间比较短，随着程序丢弃不使用的对象，垃圾收集器将从最年轻的子堆中收集这些对象。在分代式的垃圾收集器运行后，上次运行存活下来的对象移到下一最高代的子堆中，由于老一代的子堆不会经常被回收，因而节省了时间。 

      6. adaptive算法
      在特定的情况下，一些垃圾收集算法会优于其它算法。基于Adaptive算法的垃圾收集器就是监控当前堆的使用情况，并将选择适当算法的垃圾收集器。

      

      通过对以上各算法的对比，我们可以看出，这些算法的目的在于尽可能的高效的去回收所有的垃圾内存。为了发现内存泄露的情形，我们可以看到各算法中回收条件如下：

        1. 引用计数法 的回收条件是：对象的引用计数器为0。

        2. tracing算法、compacting算法、copying算法、 generation算法、adaptive算法的回收条件是：对象不可达。

      也就是说，一旦一个对象被引用，那么GC就无法回收，什么情况下会产生该回收而不能回收的现象（内存泄露）呢?   常见的有以下几种：

      1. 对象的循环引用： A对象指向B对象， B对象又指向A对象，这时，gc将不能回收A和B。注：引用计数算法无法解决给情形下的内存泄露，但根据对象不可达原则可以回收。无论如何，应该尽可能避免循环引用。

      2. 长生命期引用短生命期变量：比如将一个函数内部的对象返回，然后用一个class的static变量引用它，那么这个函数内部的变量将永远无法被回收，原因在于，class的static变量在加载到jvm中时就会被创建，导致那个函数内部变量一直处于被引用状态。

     关于内存泄露，在《Bitter Java》这本书中有较详细的介绍。

 

 

       参考文献：

       1.  http://www.blogjava.net/Jack2007/archive/2008/04/11/192288.html

       2.  http://www.ibm.com/developerworks/cn/java/l-JavaMemoryLeak/

 

作者： 豆博草堂

缓存算法探究

发表评论

       为什么要使用缓存？ 缓存的最大优点在于可以达到用空间换时间的效果，避免一些不必要的计算，从而提高应用程序的响应速度。

        目前有很多缓存框架，比如ehcache, memcached, memcache， OSCache等等。然而，无论何种框架，基本上就是以<key, object>这种映射机制将对象记录起来，等下次需要对象object时，先计算它的key值，然后到缓存中根据key来取，取得后返回该对象，否则创建该对象，并在一定的条件下进行缓存。另外，由于绝大多数缓存都是将对象存储在内存中，而内存又相对有限，所以不可能缓存所有对象，需要有选择的缓存，有选择的淘汰一些对象。考虑到这些，一个缓存算法必须具备缓存和淘汰机制。基于这种思想，豆博草堂设计了如下缓存算法：

Map<KeyObject, Object> cacheMap = new HashMap<KeyObject, Object>();
Map<KeyObject, Integer> visiteCountMap = new HashMap<KeyObject, Integer>();
int cacheSize = 100;
/**
* retrivee object.
*/
Object retrieve(KeyObject key){
     Object obj = null;
     if(cacheMap.containsKey(key)){
     obj = cacheMap.get(key);
     } else {
     //find given key's object from other way.

     obj = service.findObject(key);
     if(null != obj){
         cacheMap.put(key, obj);
        }
     }
         
     //increate count.

     if(visiteCountMap.containsKey(key)){
     visiteCountMap.put(key, visiteCountMap.get(key) + 1);
     } else {
     visiteCountMap.put(key, new Integer(1));
     }
    
     //eliminate some cached object while size >= 100.

     if(cacheMap.size() >= cacheSize){
     eliminate();
     }
    
     return obj;
}
/**
* eliminate object that not visited usually.
*/
void eliminate(){
    Set<KeyObject> keys = cacheMap.keySet();
    if(null != keys){
     for(KeyObject key : keys){
         if(visiteCountMap.get(key).intValue < 5){
             //eliminate the object.

                cacheMap.remove(key);
            }
        }
    }
}

           希望这个算法对你编写具备缓存机制的程序有帮助。

    作者： 豆博草堂