Skip to content


Repository files navigation


High performance in-memory cache inspired by Caffeine.

Table of Contents


Python 3.7+


pip install theine

Cache Eviction Policies

Theine provides 3 built in cache eviction policies:


Discards the least recently used items first.


An approximate LFU policy in order to boost the effectiveness of caches subject to skewed access distributions.

Theine uses an adaptive version of W-TinyLFU to get better hit ratio under different types of workloads.



An improved CLOCK replacement policy(CLOCK: an approximation of LRU), based on PyClockPro.



Key should be a Hashable object, and value can be any Python object. If key type is not str/int, Theine will generate a unique key string automatically, this unique str will use extra space in memory and increase get/set/remove overhead.

Each Cache instance will span a thread to evict expired entries proactively, and the overhead of cache instance init is relatively high. So don't create instance dynamically in your function. Django adapter will create a global cache instance autmoatically, and when using the Memoize decorator, please make sure your cache instance is created globally, instead of creating a new one in each run.

Please be aware the Cache class is not thread-safe.

from theine import Cache
from datetime import timedelta

# tlfu is the eviction policy, Theine provide 3 policies lru/tlfu/clockpro
cache = Cache("tlfu", 10000)
# without default, return None on miss
v = cache.get("key")

# with default, return default on miss
sentinel = object()
v = cache.get("key", sentinel)

# set with ttl
cache.set("key", {"foo": "bar"}, timedelta(seconds=100))

# delete from cache

# close cache, stop timing wheel thread

# clear cache

# get current cache stats, please call stats() again if you need updated stats
stats = cache.stats()
print(stats.request_count, stats.hit_count, stats.hit_rate)

# get cache max size

# get cache current size


Theine support hashable keys, so to use a decorator, a function to convert input signatures to hashable is necessary. The recommended way is specifying the function explicitly, this is approach 1, Theine also support generating key automatically, this is approach 2. Same as Theine API, if key function return type is not str/int, Theine will generate a unique key string automatically, this unique str will use extra space in memory and increase get/set/remove overhead.

- explicit key function

from theine import Cache, Memoize
from datetime import timedelta

@Memoize(Cache("tlfu", 10000), timedelta(seconds=100))
def foo(a:int) -> int:
    return a

def _(a:int) -> str:
    return f"a:{a}"


# asyncio
@Memoize(Cache("tlfu", 10000), timedelta(seconds=100))
async def foo_a(a:int) -> int:
    return a

def _(a:int) -> str:
    return f"a:{a}"

await foo_a(1)


  • Both sync and async support.
  • Explicitly control how key is generated. Most remote cache(redis, memcached...) only allow string keys, return a string in key function make it easier when you want to use remote cache later.
  • Thundering herd protection(multithreading: set lock=True in Memoize, asyncio: always enabled).
  • Type checked. Mypy can check key function to make sure it has same input signature as original function and return a hashable.


  • You have to use 2 functions.
  • Performance. Theine API: around 8ms/10k requests ->> decorator: around 12ms/10k requests.

- auto key function

from theine import Cache, Memoize
from datetime import timedelta

@Memoize(Cache("tlfu", 10000), timedelta(seconds=100), typed=True)
def foo(a:int) -> int:
    return a


# asyncio
@Memoize(Cache("tlfu", 10000), timedelta(seconds=100), typed=True)
async def foo_a(a:int) -> int:
    return a

await foo_a(1)


  • Same as explicit key version.
  • No extra key function.


  • Worse performance: around 18ms/10k requests.
  • Unexpected memory usage. The auto key function use same methods as Python's lru_cache. Take a look this issue or this one.

Django Cache Backend

    "default": {
        "BACKEND": "theine.adapters.django.Cache",
        "TIMEOUT": 300,
        "OPTIONS": {"MAX_ENTRIES": 10000, "POLICY": "tlfu"},

Metadata Memory Overhead

Assume your key is 24 bytes long, then each meta key entry in Rust is 92 bytes. For 1 million keys, the total memory overhead is 92 megabytes. Clock-Pro will use 2x meta space, which is 184 megabytes.


Python version: 3.11

OS: Ubuntu 22.04.2 LTS

continuous benchmark

10k requests



Source Code:

Write and Mix Zipf use 1k max cache size, so you can see the high cost of traditional LFU eviction policy here.

Read Write Mix Zipf
Theine(Clock-Pro) API 3.07 ms 9.86 ms
Theine(W-TinyLFU) API 3.42 ms 10.14 ms
Theine(W-TinyLFU) Auto-Key Decorator 7.17 ms 18.41 ms 13.18 ms
Theine(W-TinyLFU) Custom-Key Decorator 6.45 ms 17.67 ms 11.50 ms
Cachetools LFU Decorator 15.70 ms 627.10 ms 191.04 ms
Cacheout LFU Decorator 50.05 ms 704.70 ms 250.95 ms
Theine(LRU) Custom-Key Decorator 5.70 ms 16.04 ms 10.91 ms
Cachetools LRU Decorator 14.05 ms 61.06 ms 36.89 ms
Cacheout LRU Decorator 47.90 ms 94.94 ms 68.25 ms

hit ratios

All hit ratio benchmarks use small datasets and finish in seconds/minutes, better to try Theine yourself and focus on whether the cache exceeds your performance needs and has the desired capabilities.

Source Code:


hit ratios search

This trace is described as "disk read accesses initiated by a large commercial search engine in response to various web search requests." hit ratios database

This trace is described as "a database server running at a commercial site running an ERP application on top of a commercial database." hit ratios Scarabresearch database trace

Scarabresearch 1 hour database trace from this issue hit ratios Meta anonymized trace

Meta shared anonymized trace captured from large scale production cache services, from cachelib hit ratios


Open an issue, ask question in discussions or join discord channel:

Theine Go version is also available, which focus on concurrency performance, take a look if you are interested: Theine Go.