自动清除容器中的元素的List

chinarocky

1. import java.util.AbstractList;
   
2. import java.util.Date;
   
3. import java.util.Iterator;
   
4. import java.util.LinkedHashMap;
   
5. import java.util.List;
   
6. import java.util.Map;
   
7. import java.util.Timer;
   
8. import java.util.TimerTask;
   
9. import java.util.concurrent.locks.ReentrantLock;
   
10. 
    
11. /**
    
12. * This class provides a simple implementation of the AbstractList.
    
13. * It keeps a deamon thread to remove the element of LinkedHashMap in it,
    
14. * so all the method for removing is not provided.
    
15. * AutoDrownList is synchronized.
    
16. * @author whaon
    
17. * @date 2015年6月11日
    
18. * @version 0.1
    
19. */
    
20. public class AutoDrownList<T> extends AbstractList<T> {
    
21.     //Map<T, Long> m = Collections.synchronizedMap(new LinkedHashMap());
    
22.      
    
23.     ReentrantLock lock = new ReentrantLock();
    
24.     Map<T, Long> m = new LinkedHashMap<T, Long>();
    
25.      
    
26.     private static final long SECONDS = 1000;
    
27.      
    
28.     private long interval;
    
29.      
    
30.     private long ttl;
    
31.      
    
32.     private Timer timer;
    
33.      
    
34.     /**
    
35.      *
    
36.      * @param interval:time in seconds for task executions.
    
37.      * @param ttl:time to live for element
    
38.      */
    
39.     public AutoDrownList(long interval, long ttl) {
    
40.         this.interval = interval * SECONDS;
    
41.         this.ttl = ttl * SECONDS;
    
42.         start();
    
43.     }
    
44.      
    
45.     @Override
    
46.     public boolean add(T t) {
    
47.         lock.lock();
    
48.         try {
    
49.             if(m.containsKey(t)) {
    
50.                 return false;
    
51.             }
    
52.             m.put(t, System.currentTimeMillis());
    
53.         } finally {
    
54.             lock.unlock();
    
55.         }
    
56.          
    
57.         return true;
    
58.     }
    
59.      
    
60.     private void start() {
    
61.         timer = new Timer("MaintainList-" + new Date(), true);
    
62.         timer.schedule(new MaintainListTimerTask(m), 0, interval);
    
63.     }
    
64.      
    
65.     private class MaintainListTimerTask extends TimerTask {
    
66.          
    
67.         Map<T, Long> m;
    
68.          
    
69.         MaintainListTimerTask(Map<T, Long> m) {
    
70.             this.m = m;
    
71.         }
    
72. 
    
73.         @Override
    
74.         public void run() {
    
75.             long now = System.currentTimeMillis();
    
76.             lock.lock();
    
77.             try {
    
78.                 Iterator<Map.Entry<T, Long>> i = m.entrySet().iterator();
    
79.                 while(i.hasNext()) {
    
80.                     Map.Entry<T, Long> e = i.next();
    
81.                     //System.out.println(e.getKey() + "/" + e.getValue());
    
82.                     if((now - e.getValue()) > ttl) {
    
83.                         i.remove();
    
84.                     } else {
    
85.                         break;
    
86.                     }
    
87.                 }
    
88.             } finally {
    
89.                 lock.unlock();
    
90.             }
    
91.         }
    
92.          
    
93.     }
    
94.      
    
95.     @Override
    
96.     public String toString() {
    
97.         return "MaintainList [m=" + m + "]";
    
98.     }
    
99. 
    
100.     @Override
     
101.     public T get(int index) {
     
102.         T t = null;
     
103.         if(index < 0) {
     
104.             return null;
     
105.         }
     
106.         lock.lock();
     
107.         try {
     
108.             Iterator<T> it = m.keySet().iterator();
     
109.             while(it.hasNext()) {
     
110.                 t = it.next();
     
111.                 if(index-- == 0) {
     
112.                     break;
     
113.                 }
     
114.             }
     
115.             
     
116.         } finally {
     
117.             lock.unlock();
     
118.         }
     
119.         return t;
     
120.     }
     
121. 
     
122.     @Override
     
123.     public int size() {
     
124.         int ret = 0;
     
125.         lock.lock();
     
126.         try {
     
127.             ret = m.size();
     
128.         } finally {
     
129.             lock.unlock();
     
130.         }
     
131.         return ret;
     
132.     }
     
133.      
     
134.      
     
135. }

复制代码