storm实战--TimeCacheMap的使用

经过实践发现，原文对TimeCacheMap的使用是错误的（#线下方是原文章），实现TimeCacheMap的序列化后，TimeCacheMap的自动删除的功能将失效。原因应该是在序列化过程中TimeCacheMap的自动删除线程将会对原集合进行深度拷贝，然后每次的清理将在新的集合上进行，原集合的数据将不会被清理。

正确的使用方法是：在你的bolt的开头声明你用于保存信息的集合，然后在prepare方法中对其进行初始化。

#################################

最近在调研storm的使用，在网上发现TimeCacheMap的介绍，觉得挺好用，就在自己的demo中使用了这个类，结果发现并没有介绍中的那样好，每次运行的时候，都会报一个不能序列化的异常：java.lang.RuntimeException: java.io.NotSerializableException: backtype.storm.utils.TimeCacheMap。

我觉得这挺诡异的，storm自己提供的东西居然不能用，我想可能是我自己使用的方法不对吧，在网上也没有找到相关介绍。放弃只用这个类又不舍得，毕竟它能够自动清除过期的数据，而且耗时超短，然后我就找到这个类的源代码，自己给他实现了序列化。

下边是这个类的源代码：

public class TimeCacheMap<K, V> {
    //this default ensures things expire at most 50% past the expiration time
    private static final int DEFAULT_NUM_BUCKETS = 3;


    public static interface ExpiredCallback<K, V> {
        public void expire(K key, V val);
    }


    private LinkedList<HashMap<K, V>> _buckets;


    private final Object _lock = new Object();
    private Thread _cleaner;
    private ExpiredCallback _callback;
    
    public TimeCacheMap(int expirationSecs, int numBuckets, ExpiredCallback<K, V> callback) {
        if(numBuckets<2) {
            throw new IllegalArgumentException("numBuckets must be >= 2");
        }
        _buckets = new LinkedList<HashMap<K, V>>();
        for(int i=0; i<numBuckets; i++) {
            _buckets.add(new HashMap<K, V>());
        }

        _callback = callback;
        final long expirationMillis = expirationSecs * 1000L;
        final long sleepTime = expirationMillis / (numBuckets-1);
        _cleaner = new Thread(new Runnable() {
            public void run() {
                try {
                    while(true) {
                        Map<K, V> dead = null;
                        Time.sleep(sleepTime);
                        synchronized(_lock) {
                            dead = _buckets.removeLast();
                            _buckets.addFirst(new HashMap<K, V>());
                        }
                        if(_callback!=null) {
                            for(Entry<K, V> entry: dead.entrySet()) {
                                _callback.expire(entry.getKey(), entry.getValue());
                            }
                        }
                    }
                } catch (InterruptedException ex) {


                }
            }
        });
        _cleaner.setDaemon(true);
        _cleaner.start();
    }


    public TimeCacheMap(int expirationSecs, ExpiredCallback<K, V> callback) {
        this(expirationSecs, DEFAULT_NUM_BUCKETS, callback);
    }


    public TimeCacheMap(int expirationSecs) {
        this(expirationSecs, DEFAULT_NUM_BUCKETS);
    }


    public TimeCacheMap(int expirationSecs, int numBuckets) {
        this(expirationSecs, numBuckets, null);
    }




    public boolean containsKey(K key) {
        synchronized(_lock) {
            for(HashMap<K, V> bucket: _buckets) {
                if(bucket.containsKey(key)) {
                    return true;
                }
            }
            return false;
        }
    }


    public V get(K key) {
        synchronized(_lock) {
            for(HashMap<K, V> bucket: _buckets) {
                if(bucket.containsKey(key)) {
                    return bucket.get(key);
                }
            }
            return null;
        }
    }


    public void put(K key, V value) {
        synchronized(_lock) {
            Iterator<HashMap<K, V>> it = _buckets.iterator();
            HashMap<K, V> bucket = it.next();
            bucket.put(key, value);
            while(it.hasNext()) {
                bucket = it.next();
                bucket.remove(key);
            }
        }
    }
    
    public Object remove(K key) {
        synchronized(_lock) {
            for(HashMap<K, V> bucket: _buckets) {
                if(bucket.containsKey(key)) {
                    return bucket.remove(key);
                }
            }
            return null;
        }
    }


   		public int size() {
        	synchronized(_lock) {
            			int size = 0;
            			for(HashMap<K, V> bucket: _buckets) {
                			size+=bucket.size();
	            		}
        	    		return size;
        		}
    		}


    		@Override
   	 	protected void finalize() throws Throwable {
        		try {
          			  _cleaner.interrupt();
        		} finally {
           		 	super.finalize();
       		 	}
   		 }
	}

首先我给这个类添加了Serializable接口：

public class TimeCacheMapS<K, V> implements Serializable{
	。。。
	}

然后运行，结果又报了一个不能序列化的异常：java.lang.RuntimeException: java.io.NotSerializableException: java.lang.Thread

原来是这个类里面含有Thread、Object和一个接口ExpiredCallback是不能序列化的。

然后依次解决这三个问题：

首先是Thread类：

我新建了一个简单的实现了Serializable接口的线程类：

	package izp.storm.basic;
	import java.io.Serializable;

	public class ThreadS extends Thread implements Serializable{
	
		public ThreadS(Runnable runa){
			super(runa);
		}
		public ThreadS(){
			
		};
	}

然后将新的TimeCacheMap类里的Thread替换为ThreadS。

我发现这个类里的这个Object对象_lock是用来给线程做加锁用的，我就把类里面用到_lock的地方都替换成了this，如下：

	 public void put(K key, V value) {
        	synchronized(this) {
            		Iterator<HashMap<K, V>> it = _buckets.iterator();
            		HashMap<K, V> bucket = it.next();
            		bucket.put(key, value);
            		while(it.hasNext()) {
                		bucket = it.next();
                		bucket.remove(key);
	            	}
        	}
    	}

最后给ExpiredCallback接口继承Serializable：

	public static interface ExpiredCallback<K, V> extends Serializable{
        	public void expire(K key, V val);
    	}

然后运行，成功。