@@ -33,11 +33,14 @@ class TagAwareAdapter implements TagAwareAdapterInterface, PruneableInterface, R
     private $getTagsByKey;
     private $invalidateTags;
     private $tags;
+    private $knownTagVersions = array();
+    private $knownTagVersionsTtl;
 
-    public function __construct(AdapterInterface $itemsPool, AdapterInterface $tagsPool = null)
+    public function __construct(AdapterInterface $itemsPool, AdapterInterface $tagsPool = null, $knownTagVersionsTtl = 0.15)
     {
         $this->pool = $itemsPool;
         $this->tags = $tagsPool ?: $itemsPool;
+        $this->knownTagVersionsTtl = $knownTagVersionsTtl;
         $this->createCacheItem = \Closure::bind(
             function ($key, $value, CacheItem $protoItem) {
                 $item = new CacheItem();
@@ -87,8 +90,7 @@ function ($deferred) {
         );
         $this->invalidateTags = \Closure::bind(
             function (AdapterInterface $tagsAdapter, array $tags) {
-                foreach ($tagsAdapter->getItems($tags) as $v) {
-                    $v->set(1 + (int) $v->get());
+                foreach ($tags as $v) {
                     $v->defaultLifetime = 0;
                     $v->expiry = null;
                     $tagsAdapter->saveDeferred($v);
@@ -106,14 +108,42 @@ function (AdapterInterface $tagsAdapter, array $tags) {
      */
     public function invalidateTags(array $tags)
     {
-        foreach ($tags as $k => $tag) {
-            if ('' !== $tag && \is_string($tag)) {
-                $tags[$k] = $tag.static::TAGS_PREFIX;
+        $ok = true;
+        $tagsByKey = array();
+        $invalidatedTags = array();
+        foreach ($tags as $tag) {
+            CacheItem::validateKey($tag);
+            $invalidatedTags[$tag] = 0;
+        }
+
+        if ($this->deferred) {
+            $items = $this->deferred;
+            foreach ($items as $key => $item) {
+                if (!$this->pool->saveDeferred($item)) {
+                    unset($this->deferred[$key]);
+                    $ok = false;
+                }
             }
+
+            $f = $this->getTagsByKey;
+            $tagsByKey = $f($items);
+            $this->deferred = array();
+        }
+
+        $tagVersions = $this->getTagVersions($tagsByKey, $invalidatedTags);
+        $f = $this->createCacheItem;
+
+        foreach ($tagsByKey as $key => $tags) {
+            $this->pool->saveDeferred($f(static::TAGS_PREFIX.$key, array_intersect_key($tagVersions, $tags), $items[$key]));
+        }
+        $ok = $this->pool->commit() && $ok;
+
+        if ($invalidatedTags) {
+            $f = $this->invalidateTags;
+            $ok = $f($this->tags, $invalidatedTags) && $ok;
         }
-        $f = $this->invalidateTags;
 
-        return $f($this->tags, $tags);
+        return $ok;
     }
 
     /**
@@ -132,7 +162,7 @@ public function hasItem($key)
         }
 
         foreach ($this->getTagVersions(array($itemTags)) as $tag => $version) {
-            if ($itemTags[$tag] !== $version) {
+            if ($itemTags[$tag] !== $version && 1 !== $itemTags[$tag] - $version) {
                 return false;
             }
         }
@@ -241,29 +271,7 @@ public function saveDeferred(CacheItemInterface $item)
      */
     public function commit()
     {
-        $ok = true;
-
-        if ($this->deferred) {
-            $items = $this->deferred;
-            foreach ($items as $key => $item) {
-                if (!$this->pool->saveDeferred($item)) {
-                    unset($this->deferred[$key]);
-                    $ok = false;
-                }
-            }
-
-            $f = $this->getTagsByKey;
-            $tagsByKey = $f($items);
-            $this->deferred = array();
-            $tagVersions = $this->getTagVersions($tagsByKey);
-            $f = $this->createCacheItem;
-
-            foreach ($tagsByKey as $key => $tags) {
-                $this->pool->saveDeferred($f(static::TAGS_PREFIX.$key, array_intersect_key($tagVersions, $tags), $items[$key]));
-            }
-        }
-
-        return $this->pool->commit() && $ok;
+        return $this->invalidateTags(array());
     }
 
     public function __destruct()
@@ -294,7 +302,7 @@ private function generateItems($items, array $tagKeys)
 
                 foreach ($itemTags as $key => $tags) {
                     foreach ($tags as $tag => $version) {
-                        if ($tagVersions[$tag] !== $version) {
+                        if ($tagVersions[$tag] !== $version && 1 !== $version - $tagVersions[$tag]) {
                             unset($itemTags[$key]);
                             continue 2;
                         }
@@ -310,23 +318,54 @@ private function generateItems($items, array $tagKeys)
         }
     }
 
-    private function getTagVersions(array $tagsByKey)
+    private function getTagVersions(array $tagsByKey, array &$invalidatedTags = array())
     {
-        $tagVersions = array();
+        $tagVersions = $invalidatedTags;
 
         foreach ($tagsByKey as $tags) {
             $tagVersions += $tags;
         }
 
-        if ($tagVersions) {
-            $tags = array();
-            foreach ($tagVersions as $tag => $version) {
-                $tagVersions[$tag] = $tag.static::TAGS_PREFIX;
-                $tags[$tag.static::TAGS_PREFIX] = $tag;
+        if (!$tagVersions) {
+            return array();
+        }
+
+        if (!$fetchTagVersions = 1 !== \func_num_args()) {
+            foreach ($tagsByKey as $tags) {
+                foreach ($tags as $tag => $version) {
+                    if ($tagVersions[$tag] > $version) {
+                        $tagVersions[$tag] = $version;
+                    }
+                }
+            }
+        }
+
+        $now = microtime(true);
+        $tags = array();
+        foreach ($tagVersions as $tag => $version) {
+            $tags[$tag.static::TAGS_PREFIX] = $tag;
+            if ($fetchTagVersions || !isset($this->knownTagVersions[$tag])) {
+                continue;
+            }
+            $version -= $this->knownTagVersions[$tag][1];
+            if ((0 !== $version && 1 !== $version) || $this->knownTagVersionsTtl > $now - $this->knownTagVersions[$tag][0]) {
+                // reuse previously fetched tag versions up to the ttl, unless we are storing items or a potential miss arises
+                $fetchTagVersions = true;
+            } else {
+                $this->knownTagVersions[$tag][1] += $version;
             }
-            foreach ($this->tags->getItems($tagVersions) as $tag => $version) {
-                $tagVersions[$tags[$tag]] = $version->get() ?: 0;
+        }
+
+        if (!$fetchTagVersions) {
+            return $tagVersions;
+        }
+
+        foreach ($this->tags->getItems(array_keys($tags)) as $tag => $version) {
+            $tagVersions[$tag = $tags[$tag]] = $version->get() ?: 0;
+            if (isset($invalidatedTags[$tag])) {
+                $invalidatedTags[$tag] = $version->set(++$tagVersions[$tag]);
             }
+            $this->knownTagVersions[$tag] = array($now, $tagVersions[$tag]);
         }
 
         return $tagVersions;
 
@@ -71,6 +71,22 @@ public function testInvalidateTags()
         $this->assertTrue($pool->getItem('foo')->isHit());
     }
 
+    public function testInvalidateCommits()
+    {
+        $pool1 = $this->createCachePool();
+
+        $foo = $pool1->getItem('foo');
+        $foo->tag('tag');
+
+        $pool1->saveDeferred($foo->set('foo'));
+        $pool1->invalidateTags(array('tag'));
+
+        $pool2 = $this->createCachePool();
+        $foo = $pool2->getItem('foo');
+
+        $this->assertTrue($foo->isHit());
+    }
+
     public function testTagsAreCleanedOnSave()
     {
         $pool = $this->createCachePool();