cache

diff --git a/src/main/java/br/ufrgs/inf/prosoft/cache/MultiCache.java b/src/main/java/br/ufrgs/inf/prosoft/cache/MultiCache.java
index 756703b..580d779 100644
--- a/src/main/java/br/ufrgs/inf/prosoft/cache/MultiCache.java
+++ b/src/main/java/br/ufrgs/inf/prosoft/cache/MultiCache.java
@@ -20,7 +20,8 @@ public class MultiCache<K, V> implements Cache<K, V> {
 
     private static final boolean CACHE_REGISTER_SIZE = System.getenv("CACHE_REGISTER_SIZE") != null && System.getenv("CACHE_REGISTER_SIZE").equals("true");
     private final HashMap<K, Optional<V>> map;
-    private final CachePerformance cachingPerformance;
+    private final HashMap<K, Thread> keyHasTTL;
+    private final CachePerformance cachePerformance;
     private static final Logger LOGGER = Logger.getLogger(Cache.class.getName());
 
     public MultiCache() {
@@ -32,12 +33,13 @@ public class MultiCache<K, V> implements Cache<K, V> {
     }
 
     public MultiCache(CachePerformance cachingPerformance) {
-        this.cachingPerformance = cachingPerformance;
+        this.cachePerformance = cachingPerformance;
         this.map = new HashMap<>();
+        this.keyHasTTL = new HashMap<>();
     }
 
-    public CachePerformance getCachingPerformance() {
-        return this.cachingPerformance;
+    public CachePerformance getCachePerformance() {
+        return this.cachePerformance;
     }
 
     @Override
@@ -46,11 +48,12 @@ public class MultiCache<K, V> implements Cache<K, V> {
         Thread thread = new Thread(() -> {
             try {
                 Thread.sleep(timeToLive);
+                invalidate(key);
             } catch (InterruptedException ex) {
-                LOGGER.log(Level.SEVERE, "interrupted time to live");
+                LOGGER.log(Level.WARNING, "interrupted time to live");
             }
-            invalidate(key);
         });
+        this.keyHasTTL.put(key, thread);
         thread.start();
     }
 
@@ -61,40 +64,44 @@ public class MultiCache<K, V> implements Cache<K, V> {
         this.map.put(key, optional);
         String identifier = getIdentifier(value);
         if (CACHE_REGISTER_SIZE) {
-            this.cachingPerformance.registerEvent(EventType.ADDITION, identifier, CachePerformance.calculateObjectSize(value));
+            this.cachePerformance.registerEvent(EventType.ADDITION, identifier, CachePerformance.calculateObjectSize(value));
         } else {
-            this.cachingPerformance.registerEvent(EventType.ADDITION, identifier);
+            this.cachePerformance.registerEvent(EventType.ADDITION, identifier);
         }
-        this.cachingPerformance.registerSize(this.map.size());
+        this.cachePerformance.registerSize(this.map.size());
     }
 
     @Override
     public V get(K key) {
         Optional<V> optional = this.map.get(key);
         if (optional == null) {
-            this.cachingPerformance.registerEvent(EventType.MISS);
+            this.cachePerformance.registerEvent(EventType.MISS);
             return null;
         }
         V get = optional.orElse(null);
         String identifier = getIdentifier(get);
         if (CACHE_REGISTER_SIZE) {
-            this.cachingPerformance.registerEvent(EventType.HIT, identifier, CachePerformance.calculateObjectSize(get));
+            this.cachePerformance.registerEvent(EventType.HIT, identifier, CachePerformance.calculateObjectSize(get));
         } else {
-            this.cachingPerformance.registerEvent(EventType.HIT, identifier);
+            this.cachePerformance.registerEvent(EventType.HIT, identifier);
         }
         return get;
     }
 
     @Override
     public void invalidate(K key) {
+        Thread timeToLiveThread = this.keyHasTTL.remove(key);
+        if (timeToLiveThread != null) {
+            timeToLiveThread.interrupt();
+        }
         Optional<V> optional = this.map.remove(key);
         if (optional != null) {
             V remove = optional.orElse(null);
             String identifier = getIdentifier(remove);
             if (CACHE_REGISTER_SIZE) {
-                this.cachingPerformance.registerEvent(EventType.INVALIDATION, identifier, CachePerformance.calculateObjectSize(remove));
+                this.cachePerformance.registerEvent(EventType.INVALIDATION, identifier, CachePerformance.calculateObjectSize(remove));
             } else {
-                this.cachingPerformance.registerEvent(EventType.INVALIDATION, identifier);
+                this.cachePerformance.registerEvent(EventType.INVALIDATION, identifier);
             }
         }
     }

diff --git a/src/main/java/br/ufrgs/inf/prosoft/cache/SingleCache.java b/src/main/java/br/ufrgs/inf/prosoft/cache/SingleCache.java
index 34d9c51..8dc23a6 100644
--- a/src/main/java/br/ufrgs/inf/prosoft/cache/SingleCache.java
+++ b/src/main/java/br/ufrgs/inf/prosoft/cache/SingleCache.java
@@ -13,6 +13,8 @@ package br.ufrgs.inf.prosoft.cache;
  */
 public class SingleCache<K, V> extends MultiCache<K, V> {
 
+    private K lastInput;
+
     public SingleCache() {
         super();
     }
@@ -24,4 +26,11 @@ public class SingleCache<K, V> extends MultiCache<K, V> {
     public SingleCache(CachePerformance cachingPerformance) {
         super(cachingPerformance);
     }
+
+    @Override
+    public void put(K key, V value) {
+        invalidate(this.lastInput);
+        this.lastInput = key;
+        super.put(key, value);
+    }
 }