缓存命中率

概念定义

命中率回答“缓存避免了多少工作”。但两个比率回答不同问题：请求命中率衡量多少调用者避开了源站，字节命中率衡量源站省了多少带宽——一个缓存完全可能一好一坏。

工作机制

计数按层发生：边缘命中、护盾命中、源站。优化会把 miss 在层间搬移——护盾把源站抓取变成护盾命中，抬高边缘加护盾的比率同时降低源站负载。指标应按路由、内容类别、区域分段，才能定位回归。

使用场景

按业务问题定义目标指标：出口成本看字节率，源站 CPU 看请求率。两者都追踪，外加源站 QPS 与延迟，命中率上升才掩盖不了服务变慢。

常见误区

“命中率高就是页面快”不成立：小对象命中撑高请求率，大对象继续 miss 并主导字节与延迟。个性化与 vary 密集的流量在结构上压低命中率——要对比自身分段的基线，而非跨系统民间传说。部署刷缓存造成的锯齿若不做标注会误导周报。

代码示例

package main

import (
	"context"
	"fmt"
	"sync"
	"time"

	"golang.org/x/sync/singleflight"
)

type Store struct {
	mu    sync.RWMutex
	cache map[string]entry
	group singleflight.Group
}

type entry struct {
	value   string
	expires time.Time
}

func NewStore(ttl time.Duration) *Store {
	return &Store{cache: make(map[string]entry)}
}

func (s *Store) Get(ctx context.Context, key string, ttl time.Duration) (string, error) {
	s.mu.RLock()
	e, ok := s.cache[key]
	s.mu.RUnlock()

	if ok && time.Now().Before(e.expires) {
		return e.value, nil // 命中：新鲜数据直接返回
	}

	v, err, _ := s.group.Do(key, func() (interface{}, error) {
		value, loadErr := slowLoad(ctx, key) // 同 key 并发只执行一次
		if loadErr != nil {
			return nil, loadErr
		}
		s.mu.Lock()
		s.cache[key] = entry{value: value, expires: time.Now().Add(ttl)}
		s.mu.Unlock()
		return value, nil
	})
	if err != nil {
		if ok {
			return e.value, nil // 回源失败时降级旧值
		}
		return "", err
	}
	return v.(string), nil
}

func slowLoad(_ context.Context, key string) (string, error) {
	time.Sleep(50 * time.Millisecond)
	return "value-for-" + key, nil
}

func main() {
	store := NewStore(time.Minute)

	var wg sync.WaitGroup
	for i := 0; i < 10; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			v, _ := store.Get(context.Background(), "config", time.Minute)
			fmt.Println(v)
		}()
	}
	wg.Wait()
}

import asyncio
import functools
import json

import redis.asyncio as redis

pool = redis.ConnectionPool.from_url('redis://localhost:6379/0')
client = redis.Redis(connection_pool=pool)


def async_cache(ttl: int = 60):
    def decorator(fn):
        @functools.wraps(fn)
        async def wrapper(*args, **kwargs):
            key = f'cache:{fn.__module__}:{fn.__qualname__}:{args!r}:{sorted(kwargs.items())!r}'
            cached = await client.get(key)
            if cached is not None:
                return json.loads(cached)

            lock_key = key + ':lock'
            # 简化版单飞：拿不到锁的并发请求稍候后直接读缓存
            got_lock = await client.set(lock_key, '1', nx=True, ex=ttl)
            if got_lock:
                try:
                    value = await fn(*args, **kwargs)
                    await client.set(key, json.dumps(value), ex=ttl)
                    return value
                finally:
                    await client.delete(lock_key)

            await asyncio.sleep(0.05)
            cached = await client.get(key)
            if cached is not None:
                return json.loads(cached)
            return await fn(*args, **kwargs)

        return wrapper

    return decorator


@async_cache(ttl=90)
async def exchange_rates(base: str) -> dict:
    print(f'cache miss: fetching rates for {base}')
    await asyncio.sleep(0.3)
    return {'base': base, 'usd': 1.0, 'eur': 0.92}


async def main() -> None:
    first, second = await asyncio.gather(
        exchange_rates('usd'), exchange_rates('usd')
    )
    print('single flight result equal:', first == second)
    await client.aclose()


asyncio.run(main())