基于 TTL 的缓存数据过期清理策略

缓存与 TTL 概述

在后端开发的分布式系统中，缓存扮演着至关重要的角色。缓存能够显著提升系统性能，减少数据库等持久化存储的压力。简单来说，缓存就是在内存中存储经常访问的数据副本，这样当再次请求相同数据时，就可以直接从缓存中获取，而无需经过较慢的数据库查询等操作。

TTL（Time - To - Live，生存时间）是缓存数据的一个重要属性。它表示缓存数据在缓存中可以存活的时长。当数据在缓存中的时间超过 TTL 设定的值时，该数据就被认为过期了。合理设置 TTL 对于缓存的有效性和系统资源的合理利用非常关键。如果 TTL 设置过长，可能会导致缓存数据长时间保持陈旧，无法及时反映数据库中的最新变化；而如果 TTL 设置过短，可能会频繁地从数据库中重新获取数据，降低了缓存的效益。

基于 TTL 的缓存数据过期清理策略的核心原理

基于 TTL 的缓存数据过期清理策略，核心在于通过记录每个缓存数据项的创建时间或者上次更新时间，并结合预设的 TTL 值，来判断数据是否过期。当有请求访问缓存数据时，首先检查该数据是否过期，如果过期则从缓存中移除该数据，或者重新从数据源（如数据库）获取最新数据并更新缓存。

在分布式系统中，这种策略的实现面临一些挑战。因为分布式系统中可能存在多个缓存节点，每个节点都需要独立维护和管理缓存数据的过期状态。此外，缓存数据的更新和删除操作需要在各个节点之间保持一致性，以避免不同节点上出现数据不一致的情况。

实现方式分类

被动过期检查

被动过期检查是指在每次请求访问缓存数据时，检查该数据是否过期。如果过期，则从缓存中删除该数据，并从数据源重新获取数据更新缓存。这种方式实现相对简单，代码示例如下（以 Python 和 Redis 为例）：

import redis
import time

# 连接 Redis
r = redis.Redis(host='localhost', port=6379, db = 0)

def get_data_from_cache_or_db(key, ttl, get_from_db_func):
    data = r.get(key)
    if data is not None:
        # 这里假设 Redis 没有直接提供判断数据是否过期的方法，我们可以自己记录过期时间
        expiration_time = r.get(key + '_expiration')
        if expiration_time is not None and float(expiration_time) > time.time():
            return data.decode('utf - 8')
        else:
            r.delete(key)
            r.delete(key + '_expiration')

    # 从数据库获取数据
    new_data = get_from_db_func()
    r.set(key, new_data)
    r.set(key + '_expiration', time.time() + ttl)
    return new_data

这种方式的优点是实现简单，对系统资源消耗相对较小，因为只有在数据被请求时才进行过期检查。然而，它的缺点也很明显，在数据过期到下次请求之间，系统可能会一直使用过期的数据。而且，如果在短时间内大量数据过期且同时被请求，可能会给数据库带来较大压力，因为需要同时从数据库获取大量数据。

主动过期检查

主动过期检查是指系统定期扫描缓存，主动删除过期的数据。这种方式可以确保缓存中的数据及时更新，避免使用过期数据。以 Java 和 Ehcache 为例，代码示例如下：

import net.sf.ehcache.Cache;
import net.sf.ehcache.CacheManager;
import net.sf.ehcache.Element;
import java.util.Timer;
import java.util.TimerTask;

public class CacheExpirationManager {
    private static final CacheManager cacheManager = CacheManager.create();
    private static final Cache cache = new Cache("myCache", 1000, false, false, 3600, 3600);

    static {
        cacheManager.addCache(cache);
        startExpirationCheck();
    }

    private static void startExpirationCheck() {
        Timer timer = new Timer();
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                long currentTime = System.currentTimeMillis();
                for (Object key : cache.getKeys()) {
                    Element element = cache.get(key);
                    if (element != null) {
                        long creationTime = element.getCreationTime();
                        long ttl = element.getTimeToLive();
                        if (currentTime - creationTime > ttl * 1000) {
                            cache.remove(key);
                        }
                    }
                }
            }
        }, 0, 60 * 1000); // 每分钟检查一次
    }

    public static String getFromCacheOrLoad(String key, Supplier<String> loadFunction, long ttl) {
        Element element = cache.get(key);
        if (element != null) {
            return (String) element.getObjectValue();
        }
        String value = loadFunction.get();
        cache.put(new Element(key, value, 0, ttl));
        return value;
    }
}

主动过期检查的优点是可以及时清理过期数据，保证缓存数据的新鲜度。但是，它需要定期占用系统资源来扫描缓存，可能会对系统性能产生一定影响。而且，如果扫描周期设置不当，可能会导致要么资源浪费（扫描过于频繁），要么过期数据清理不及时（扫描周期过长）。

分布式系统中的特殊考虑

缓存一致性问题

在分布式缓存系统中，缓存一致性是一个关键问题。当一个节点更新了缓存数据并设置了新的 TTL，其他节点需要及时同步这些变化，以保证所有节点上的数据一致性。一种常见的解决方案是使用分布式缓存协议，如 Redis Cluster 采用的 Gossip 协议。通过这种协议，节点之间可以相互交换状态信息，从而实现数据更新和过期状态的同步。

例如，在 Redis Cluster 中，当一个节点更新了某个缓存数据的 TTL 时，它会通过 Gossip 协议将这个更新信息传播给其他节点。其他节点接收到这个信息后，会相应地更新本地缓存数据的 TTL。这样可以在一定程度上保证各个节点上缓存数据的一致性。

故障容错

分布式系统中，节点故障是不可避免的。当一个缓存节点发生故障时，基于 TTL 的过期清理策略需要能够继续正常工作。一种方法是采用冗余备份机制，例如使用主从复制或者多副本机制。在主从复制中，主节点负责处理写操作（包括设置缓存数据和 TTL），并将这些操作同步到从节点。如果主节点发生故障，可以将从节点提升为主节点继续工作。

以 Redis 的主从复制为例，主节点在设置缓存数据和 TTL 后，会将这些写操作以日志的形式记录下来，并发送给从节点。从节点根据接收到的日志进行相应的操作，从而保持与主节点的数据一致性。这样，即使主节点出现故障，从节点仍然可以继续提供缓存服务，并且基于 TTL 的过期清理策略也能在从节点上正常运行。

负载均衡

在分布式缓存系统中，负载均衡对于系统的性能和可扩展性至关重要。负载均衡器需要将请求均匀地分配到各个缓存节点上，同时要考虑到缓存数据的 TTL 情况。例如，如果某个节点上的缓存数据即将大量过期，负载均衡器可以适当减少分配到该节点的请求，以避免在数据过期时该节点因同时处理大量请求而导致性能下降。

常见的负载均衡算法有轮询算法、加权轮询算法、最少连接算法等。在基于 TTL 的缓存系统中，可以结合这些算法，根据每个节点上缓存数据的 TTL 分布情况动态调整负载均衡策略。比如，可以为即将过期数据较多的节点分配较低的权重，从而减少请求到达该节点的概率。

性能优化与调优

TTL 值的动态调整

在实际应用中，静态设置 TTL 值可能无法满足复杂多变的业务需求。可以根据数据的访问频率、更新频率等因素动态调整 TTL 值。例如，对于访问频率高且更新频率低的数据，可以适当延长 TTL 值，以提高缓存命中率；而对于更新频繁的数据，则应缩短 TTL 值，保证数据的及时性。

以 Python 和 SQLAlchemy 为例，假设我们有一个数据库表存储商品信息，并且我们希望根据商品的销售热度动态调整缓存的 TTL：

from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.orm import sessionmaker
from sqlalchemy.ext.declarative import declarative_base
import redis
import time

engine = create_engine('sqlite:///products.db')
Session = sessionmaker(bind = engine)
Base = declarative_base()

class Product(Base):
    __tablename__ = 'products'
    id = Column(Integer, primary_key = True)
    name = Column(String)
    sales_count = Column(Integer)

r = redis.Redis(host='localhost', port=6379, db = 0)

def get_product_from_cache_or_db(product_id):
    key = f'product:{product_id}'
    data = r.get(key)
    if data is not None:
        session = Session()
        product = session.query(Product).filter(Product.id == product_id).first()
        if product:
            # 根据销售热度动态调整 TTL
            if product.sales_count > 100:
                new_ttl = 3600
            else:
                new_ttl = 600
            r.setex(key, new_ttl, data)
            return data.decode('utf - 8')
        else:
            r.delete(key)

    session = Session()
    product = session.query(Product).filter(Product.id == product_id).first()
    if product:
        data = str(product.name)
        # 根据销售热度动态调整 TTL
        if product.sales_count > 100:
            ttl = 3600
        else:
            ttl = 600
        r.setex(key, ttl, data)
        return data
    return None

缓存分层策略

为了进一步优化性能，可以采用缓存分层策略。通常可以分为本地缓存和分布式缓存两层。本地缓存位于应用服务器本地内存中，访问速度极快，但容量有限。分布式缓存则提供更大的存储容量和更高的可用性。

当应用程序请求数据时，首先从本地缓存中查找。如果找到且数据未过期，则直接返回；否则，从分布式缓存中查找。如果分布式缓存中数据也过期或者不存在，则从数据源获取数据，更新分布式缓存，并根据情况决定是否更新本地缓存。这样可以大大减少对分布式缓存的访问压力，提高系统整体性能。

以 Java 应用为例，我们可以使用 Caffeine 作为本地缓存，Redis 作为分布式缓存：

import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.Caffeine;
import redis.clients.jedis.Jedis;
import java.util.concurrent.TimeUnit;

public class TwoLevelCache {
    private static final Cache<String, String> localCache = Caffeine.newBuilder()
           .expireAfterWrite(10, TimeUnit.MINUTES)
           .build();
    private static final Jedis jedis = new Jedis("localhost", 6379);

    public static String getFromCacheOrLoad(String key, Supplier<String> loadFunction, long ttl) {
        String value = localCache.getIfPresent(key);
        if (value != null) {
            return value;
        }
        value = jedis.get(key);
        if (value != null) {
            localCache.put(key, value);
            return value;
        }
        value = loadFunction.get();
        jedis.setex(key, (int) ttl, value);
        localCache.put(key, value);
        return value;
    }
}

缓存预热

缓存预热是指在系统启动时，提前将一些常用数据加载到缓存中，并设置好相应的 TTL。这样在系统正式运行时，就可以直接从缓存中获取这些数据，避免了首次请求时因缓存未命中而导致的性能延迟。

在实际应用中，可以通过读取配置文件或者数据库中的热门数据列表，然后批量将这些数据加载到缓存中。以 Python 和 Redis 为例：

import redis

r = redis.Redis(host='localhost', port=6379, db = 0)

# 假设从数据库中获取热门数据的函数
def get_popular_data_from_db():
    # 这里只是示例，实际需要连接数据库并查询数据
    return [('data1', 3600), ('data2', 7200)]

def warm_up_cache():
    data_list = get_popular_data_from_db()
    for data, ttl in data_list:
        r.setex(data, ttl, data)

if __name__ == '__main__':
    warm_up_cache()

与其他技术的结合

与消息队列的结合

在分布式系统中，消息队列可以与基于 TTL 的缓存过期清理策略很好地结合。当数据在数据库中发生更新时，可以发送一条消息到消息队列。缓存系统监听这个消息队列，当收到数据更新消息时，首先判断缓存中对应的数据是否存在。如果存在，则根据更新情况调整 TTL 或者直接删除缓存数据，以保证缓存数据与数据库的一致性。

以 RabbitMQ 作为消息队列，Python 作为开发语言为例：

import pika
import redis

r = redis.Redis(host='localhost', port=6379, db = 0)

# 连接 RabbitMQ
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()
channel.queue_declare(queue='data_updates')

def callback(ch, method, properties, body):
    key = body.decode('utf - 8')
    if r.exists(key):
        # 这里假设更新后需要缩短 TTL
        r.setex(key, 300, r.get(key))

channel.basic_consume(queue='data_updates', on_message_callback = callback, auto_ack = True)

print(' [*] Waiting for messages. To exit press CTRL+C')
channel.start_consuming()

与分布式事务的结合

在涉及到数据更新和缓存操作的场景中，分布式事务可以保证数据的一致性。例如，当一个业务操作需要更新数据库数据并同时更新缓存数据及其 TTL 时，如果不使用分布式事务，可能会出现数据库更新成功但缓存更新失败的情况，导致数据不一致。

以 Seata 分布式事务框架为例，假设我们有一个订单创建业务，在创建订单后需要更新商品库存缓存及其 TTL：

import io.seata.spring.annotation.GlobalTransactional;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class OrderService {
    @Autowired
    private OrderRepository orderRepository;
    @Autowired
    private ProductRepository productRepository;
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    @GlobalTransactional
    @Transactional
    public void createOrder(Order order) {
        orderRepository.save(order);
        Product product = productRepository.findById(order.getProductId()).get();
        product.setStock(product.getStock() - order.getQuantity());
        productRepository.save(product);
        // 更新商品库存缓存及其 TTL
        redisTemplate.opsForValue().set("product:" + order.getProductId(), product.getStock(), 3600, TimeUnit.SECONDS);
    }
}

通过这种方式，Seata 可以保证在整个业务操作中，数据库更新和缓存更新要么全部成功，要么全部失败，从而确保数据的一致性。

实践中的常见问题与解决方法

缓存雪崩

缓存雪崩是指在某一时刻，大量缓存数据同时过期，导致大量请求直接落到数据库上，造成数据库压力过大甚至崩溃。解决缓存雪崩的方法之一是对 TTL 进行随机化。例如，原本设置 TTL 为 60 分钟，可以改为在 50 - 70 分钟之间随机取值。这样可以避免大量数据在同一时刻过期。

以 Python 和 Redis 为例：

import redis
import random

r = redis.Redis(host='localhost', port=6379, db = 0)

def set_data_with_random_ttl(key, value):
    min_ttl = 300
    max_ttl = 600
    ttl = random.randint(min_ttl, max_ttl)
    r.setex(key, ttl, value)

缓存穿透

缓存穿透是指查询一个不存在的数据，由于缓存中也没有该数据，导致每次请求都直接穿透到数据库。一种解决方法是使用布隆过滤器。布隆过滤器可以快速判断一个数据是否存在。当查询数据时，先通过布隆过滤器判断，如果布隆过滤器认为数据不存在，则直接返回，不再查询数据库；如果布隆过滤器认为数据可能存在，再查询缓存和数据库。

以 Java 和 Guava 的 BloomFilter 为例：

import com.google.common.hash.BloomFilter;
import com.google.common.hash.Funnels;
import redis.clients.jedis.Jedis;

public class BloomFilterCache {
    private static final BloomFilter<String> bloomFilter = BloomFilter.create(Funnels.stringFunnel(), 10000, 0.01);
    private static final Jedis jedis = new Jedis("localhost", 6379);

    public static String getFromCacheOrLoad(String key, Supplier<String> loadFunction, long ttl) {
        if (!bloomFilter.mightContain(key)) {
            return null;
        }
        String value = jedis.get(key);
        if (value != null) {
            return value;
        }
        value = loadFunction.get();
        if (value != null) {
            jedis.setex(key, (int) ttl, value);
            bloomFilter.put(key);
        }
        return value;
    }
}

缓存击穿

缓存击穿是指一个热点数据在缓存中过期的瞬间，大量请求同时访问该数据，导致这些请求全部落到数据库上。解决缓存击穿的方法之一是使用互斥锁。在缓存数据过期时，只有一个请求能够获取到互斥锁，去数据库加载数据并更新缓存，其他请求等待。当获取锁的请求更新完缓存后，释放锁，其他请求再从缓存中获取数据。

以 Python 和 Redis 的 SETNX 命令实现互斥锁为例：

import redis
import time

r = redis.Redis(host='localhost', port=6379, db = 0)

def get_data_with_mutex(key, ttl, get_from_db_func):
    lock_key = f'{key}:lock'
    while True:
        if r.setnx(lock_key, 1):
            try:
                data = r.get(key)
                if data is not None:
                    return data.decode('utf - 8')
                new_data = get_from_db_func()
                r.setex(key, ttl, new_data)
                return new_data
            finally:
                r.delete(lock_key)
        else:
            time.sleep(0.1)

通过以上对基于 TTL 的缓存数据过期清理策略的详细介绍，包括原理、实现方式、分布式系统中的特殊考虑、性能优化、与其他技术的结合以及实践中的常见问题与解决方法，希望能帮助开发者在后端分布式系统开发中更好地运用这一策略，提升系统的性能和稳定性。