Fix #294: Avoid "cache stampedes" with cachetools.func decorators.

Author: Thomas Kemmer

src/cachetools/_decorators.py

@@ -1,6 +1,50 @@
 """Extensible memoizing decorator helpers."""
 
 
+def _cached_cond_info(func, cache, key, cond, info):
+    hits = misses = 0
+    pending = set()
+
+    def wrapper(*args, **kwargs):
+        nonlocal hits, misses
+        k = key(*args, **kwargs)
+        with cond:
+            cond.wait_for(lambda: k not in pending)
+            try:
+                result = cache[k]
+                hits += 1
+                return result
+            except KeyError:
+                pending.add(k)
+                misses += 1
+        try:
+            v = func(*args, **kwargs)
+            with cond:
+                try:
+                    cache[k] = v
+                except ValueError:
+                    pass  # value too large
+                return v
+        finally:
+            with cond:
+                pending.remove(k)
+                cond.notify_all()
+
+    def cache_clear():
+        nonlocal hits, misses
+        with cond:
+            cache.clear()
+            hits = misses = 0
+
+    def cache_info():
+        with cond:
+            return info(hits, misses)
+
+    wrapper.cache_clear = cache_clear
+    wrapper.cache_info = cache_info
+    return wrapper
+
+
 def _cached_locked_info(func, cache, key, lock, info):
     hits = misses = 0
 
@@ -139,6 +183,8 @@ def _cached_wrapper(func, cache, key, lock, info):
             wrapper = _uncached_info(func, info)
         elif lock is None:
             wrapper = _cached_unlocked_info(func, cache, key, info)
+        elif hasattr(lock, "wait_for") and hasattr(lock, "notify_all"):
+            wrapper = _cached_cond_info(func, cache, key, lock, info)
         else:
             wrapper = _cached_locked_info(func, cache, key, lock, info)
     else:

src/cachetools/func.py

@@ -7,9 +7,9 @@
 import time
 
 try:
-    from threading import RLock
+    from threading import Condition
 except ImportError:  # pragma: no cover
-    from dummy_threading import RLock
+    from dummy_threading import Condition
 
 from . import FIFOCache, LFUCache, LRUCache, RRCache, TTLCache
 from . import cached
@@ -28,7 +28,7 @@ def maxsize(self):
 def _cache(cache, maxsize, typed):
     def decorator(func):
         key = keys.typedkey if typed else keys.hashkey
-        wrapper = cached(cache=cache, key=key, lock=RLock(), info=True)(func)
+        wrapper = cached(cache=cache, key=key, lock=Condition(), info=True)(func)
         wrapper.cache_parameters = lambda: {"maxsize": maxsize, "typed": typed}
         return wrapper
 

tests/test_cached.py

@@ -214,6 +214,20 @@ def test_zero_size_cache_decorator_info(self):
         self.assertEqual(wrapper(0), 0)
         self.assertEqual(wrapper.cache_info(), (0, 1, 0, 0))
 
+    def test_zero_size_cache_decorator_lock_info(self):
+        cache = self.cache(0)
+        lock = CountedLock()
+        wrapper = cachetools.cached(cache, lock=lock, info=True)(self.func)
+
+        self.assertEqual(len(cache), 0)
+        self.assertEqual(wrapper.cache_info(), (0, 0, 0, 0))
+        self.assertEqual(lock.count, 1)
+        self.assertEqual(wrapper(0), 0)
+        self.assertEqual(len(cache), 0)
+        self.assertEqual(lock.count, 3)
+        self.assertEqual(wrapper.cache_info(), (0, 1, 0, 0))
+        self.assertEqual(lock.count, 4)
+
 
 class DictWrapperTest(unittest.TestCase, DecoratorTestMixin):
     def cache(self, minsize):