缓冲池实例剖析

在网上找了一个例子，试着运行之后，画出了他的时序图。以后便于复习

package cache;

import java.util.Date;
import java.util.HashMap;
import java.util.Map;

/**
 * 缓存池
 * @author Administrator
 */
public class CachePool { 

    // 缓存池唯一实例
    private static CachePool instance;
    // 缓存Map
    private static Map<String, Object> cacheItems;
    private CachePool() {
       cacheItems = new HashMap<String, Object>();
    }
    /**
    * 获取唯一的实例
    * @return instance
    */

    public synchronized static CachePool getInstance() {
       if (instance == null) {
           instance = new CachePool();
       }
       return instance;
    }
    /**
      * 清除所有的Item缓存
    */
    public synchronized void clearAllItems() {
      cacheItems.clear();
    }
    /**
     * 获取缓存实例
     * @param name 缓存名称
     * @return 缓存实例
    */
    public synchronized Object getCacheItem(String name) {
         if (!cacheItems.containsKey(name)) {
            return null;
         }
        CacheItem cacheItem = (CacheItem) cacheItems.get(name);
        if (cacheItem.isExpired()) {
          return null;
        }
       return cacheItem.getEntity();
    }
    /**
     * 存放缓存信息
     * @param name 名称
     * @param obj 实例对象
     * @param expires 超时时长
     */
    public synchronized void putCacheItem(String name, Object obj, long expires) {
        // 判断该对象是否在在缓存池，不在直接put
       if (!cacheItems.containsKey(name)) {
          cacheItems.put(name, new CacheItem(obj, expires));
       }
        // 获取缓存池中对象，更新对象信息
       CacheItem cacheItem = (CacheItem) cacheItems.get(name);
       cacheItem.setCreateTime(new Date());
       cacheItem.setEntity(obj);
       cacheItem.setExpireTime(expires);
     }
     /**
     * 移除缓存数据
     * @param name
     */
     public synchronized void removeCacheItem(String name) {
       if (!cacheItems.containsKey(name)) {
        return ;
       }
      cacheItems.remove(name);
     }
     /**
     * 获取缓存数据的数量
     * @return
      */
     public int getSize() {
       return cacheItems.size();
      }
}

package cache;

import java.util.Date;

public class CacheItem {
    //创建缓存的时间
    private Date createTime = new Date();
    //缓存期满时间
    private long expireTime = 1;
    //缓存实体
    private Object entity;

    public CacheItem(Object obj,long expire){
        this.entity = obj;
        this.expireTime = expire;
    }
    //判断缓存是否超时
    public boolean isExpired(){
        return (expireTime!=-1 && new Date().getTime() - createTime.getTime() > expireTime);
    }

    public Date getCreateTime() {
        return createTime;
    }
    public void setCreateTime(Date createTime) {
        this.createTime = createTime;
    }
    public Object getEntity() {
        return entity;
    }
    public void setEntity(Object entity) {
        this.entity = entity;
    }
    public long getExpireTime() {
        return expireTime;
    }
    public void setExpireTime(long expireTime) {
        this.expireTime = expireTime;
    }
}

package cache;

public class Student {
     private String name;
     private String id;
     private int age;
     private int sal;
     public Student() { 

     }
     public Student(String name, String id, int age, int sal) {
      this.name = name;
      this.id = id;
      this.age = age;
      this.sal = sal;
     }
     public String getName() {
      return name;
     }
     public void setName(String name) {
      this.name = name;
     }
     public String getId() {
      return id;
     }
     public void setId(String id) {
      this.id = id;
     }
     public int getAge() {
      return age;
     }
     public void setAge(int age) {
      this.age = age;
     }
     public int getSal() {
      return sal;
     }
     public void setSal(int sal) {
      this.sal = sal;
     }
}

package cache;

public class MainTest {
     /**
      * @param args
      * @throws InterruptedException
      */
     public static void main(String[] args) throws InterruptedException {
      // 获取缓存池
      CachePool cachePool = CachePool.getInstance();
      Student stu1 = new Student("l1", "stu001", 25, 40);
      Student stu2 = new Student("l2", "stu002", 25, 40);
      Student stu3 = new Student("l3", "stu003", 25, 40);
      Student stu4 = new Student("l4", "stu004", 25, 40);
      cachePool.putCacheItem("001", stu1, 122222);
      cachePool.putCacheItem("002", stu2, 10);
      cachePool.putCacheItem("003", stu3, 360002);
      cachePool.putCacheItem("004", stu4, 1222222);
      // 设置线程休眠，其中002对象会超时
      Thread.sleep(200);
      Student stu001 = (Student) cachePool.getCacheItem("001");
      if (null != stu001) {
       System.out.println(stu001.getName());
      }
      // 由于超时，这里取出的002对象为null
      Student stu002 = (Student) cachePool.getCacheItem("002");
      if (null != stu002) {
       System.out.println(stu002.getName());
      }
      // 获取打印缓存池中对象数量
      int cacheSize = cachePool.getSize();
      System.out.println(cacheSize);
      // 删除对象002
      cachePool.removeCacheItem("002");
      // 打印缓存池数量
      cacheSize = cachePool.getSize();
      System.out.println(cacheSize);
     }
}