timer實現定時的緩存器

1. public class CacheTimerHandler {  

2.     private static final long SECOND_TIME = 1000;//默認過時時間 20秒  

3.     private static final int DEFUALT_VALIDITY_TIME = 20;//默認過時時間 20秒  

4.     private static final Timer timer ;  

5.     private static final SimpleConcurrentMap<String, CacheEntity> map;  

6.       

7.     static{  

8.         timer = new Timer();  

9.         map = new SimpleConcurrentMap<String, CacheEntity>(new HashMap<String, CacheEntity>(1<<18));  

10.     }  

11.               

12.     /** 

13.      * 增長緩存對象 

14.      * @param key 

15.      * @param ce 

16.      */  

17.     public static void addCache(String key, CacheEntity ce){  

18.         addCache(key, ce, DEFUALT_VALIDITY_TIME);  

19.     }  

20.       

21.     /** 

22.      * 增長緩存對象 

23.      * @param key 

24.      * @param ce 

25.      * @param validityTime 有效時間 

26.      */  

27.     public static synchronized void addCache(String key, CacheEntity ce, int validityTime){  

28.         map.put(key, ce);  

29.         //添加過時定時  

30.         timer.schedule(new TimeoutTimerTask(key), validityTime * SECOND_TIME);  

31.     }  

32.       

33.     /** 

34.      * 獲取緩存對象 

35.      * @param key 

36.      * @return 

37.      */  

38.     public static synchronized CacheEntity getCache(String key){  

39.         return map.get(key);  

40.     }  

41.       

42.     /** 

43.      * 檢查是否含有制定key的緩衝 

44.      * @param key 

45.      * @return 

46.      */  

47.     public static synchronized boolean isConcurrent(String key){  

48.         return map.containsKey(key);  

49.     }  

50.       

51.     /** 

52.      * 刪除緩存 

53.      * @param key 

54.      */  

55.     public static synchronized void removeCache(String key){  

56.         map.remove(key);  

57.     }  

58.       

59.     /** 

60.      * 獲取緩存大小 

61.      * @param key 

62.      */  

63.     public static int getCacheSize(){  

64.         return map.size();  

65.     }  

66.       

67.     /** 

68.      * 清除所有緩存 

69.      */  

70.     public static synchronized void clearCache(){  

71.         if(null != timer){  

72.             timer.cancel();  

73.         }  

74.         map.clear();  

75.         System.out.println("clear cache");  

76.     }  

77.       

    
    

78.     static class TimeoutTimerTask extends TimerTask{  

79.         private String ceKey ;  

80.           

81.         public TimeoutTimerTask(String key){  

82.             this.ceKey = key;  

83.         }  

84.   

85.         @Override  

86.         public void run() {  

87.             CacheTimerHandler.removeCache(ceKey);  

88.             System.out.println("remove : "+ceKey);  

89.         }  

90.     }  

91. }  

timer方式有點是適用性更強，由於每一個緩存的過時時間均可以獨立配置的；ist只能適用 於緩存時間都同樣的線性過時。從性能開銷方面，由於timer是與緩存對象數量成正比的，在緩存量很大的時候，在緩存時間內系統開銷也隨之提升；而 list方式只要一個線程管理過時清理就能夠了。ReadWriteLock 請參考http://www.blogjava.net/xylz/archive/2010/07/14/326080.html

在這裏程序還有更好的方式來實現

使用FutureTask來獲取任務，這樣避免了每次執行相同計算工做，例如 

一個線程在執行map.put（5），此時第二個線程也是執行map.put(5)，或者執行一系列的計算，目的是get(5)這個操做，但是這個操做已經在進行了，如今咱們須要一種先進行判斷的模式，先判斷是否有線程正在執行這個操做，若是有咱們就不在執行，這樣能夠避免重覆的開銷,有線程在執行這個操做那就繼續等待其執行完，而不用再去執行一次