【redis】关于Redis数据逾期策略

127.0.0.1:6379> setex s 20 1OK127.0.0.1:6379> ttl s(integer) 17127.0.0.1:6379> setex s 200 1OK127.0.0.1:6379> ttl s(integer) 195127.0.0.1:6379> setrange s 3 100(integer) 6127.0.0.1:6379> ttl s(integer) 152127.0.0.1:6379> get s "1\x00\x00100"127.0.0.1:6379> ttl s(integer) 108127.0.0.1:6379> getset s 200"1\x00\x00100"127.0.0.1:6379> get s "200"127.0.0.1:6379> ttl s(integer) -1

127.0.0.1:6379> setex s 100 testOK127.0.0.1:6379> get s"test"127.0.0.1:6379> ttl s(integer) 94127.0.0.1:6379> type sstring127.0.0.1:6379> strlen s(integer) 4127.0.0.1:6379> persist s(integer) 1127.0.0.1:6379> ttl s(integer) -1127.0.0.1:6379> get s"test"

127.0.0.1:6379> expire s 200(integer) 1127.0.0.1:6379> ttl s(integer) 198127.0.0.1:6379> rename s ssOK127.0.0.1:6379> ttl ss(integer) 187127.0.0.1:6379> type ssstring127.0.0.1:6379> get ss"test"

/*----------------------------------------------------------------------------- * Expires API *----------------------------------------------------------------------------*/int removeExpire(redisDb *db, robj *key) {    /* An expire may only be removed if there is a corresponding entry in the     * main dict. Otherwise, the key will never be freed. */    redisAssertWithInfo(NULL,key,dictFind(db->dict,key->ptr) != NULL);    return dictDelete(db->expires,key->ptr) == DICT_OK;}void setExpire(redisDb *db, robj *key, long long when) {    dictEntry *kde, *de;    /* Reuse the sds from the main dict in the expire dict */    kde = dictFind(db->dict,key->ptr);    redisAssertWithInfo(NULL,key,kde != NULL);    de = dictReplaceRaw(db->expires,dictGetKey(kde));    dictSetSignedIntegerVal(de,when);}/* Return the expire time of the specified key, or -1 if no expire * is associated with this key (i.e. the key is non volatile) */long long getExpire(redisDb *db, robj *key) {    dictEntry *de;    /* No expire? return ASAP */    if (dictSize(db->expires) == 0 ||       (de = dictFind(db->expires,key->ptr)) == NULL) return -1;    /* The entry was found in the expire dict, this means it should also     * be present in the main dict (safety check). */    redisAssertWithInfo(NULL,key,dictFind(db->dict,key->ptr) != NULL);    return dictGetSignedIntegerVal(de);}/* Propagate expires into slaves and the AOF file. * When a key expires in the master, a DEL operation for this key is sent * to all the slaves and the AOF file if enabled. * * This way the key expiry is centralized in one place, and since both * AOF and the master->slave link guarantee operation ordering, everything * will be consistent even if we allow write operations against expiring * keys. */void propagateExpire(redisDb *db, robj *key) {    robj *argv[2];    argv[0] = shared.del;    argv[1] = key;    incrRefCount(argv[0]);    incrRefCount(argv[1]);    if (server.aof_state != REDIS_AOF_OFF)        feedAppendOnlyFile(server.delCommand,db->id,argv,2);    replicationFeedSlaves(server.slaves,db->id,argv,2);    decrRefCount(argv[0]);    decrRefCount(argv[1]);}int expireIfNeeded(redisDb *db, robj *key) {    mstime_t when = getExpire(db,key);    mstime_t now;    if (when < 0) return 0; /* No expire for this key */    /* Don't expire anything while loading. It will be done later. */    if (server.loading) return 0;    /* If we are in the context of a Lua script, we claim that time is     * blocked to when the Lua script started. This way a key can expire     * only the first time it is accessed and not in the middle of the     * script execution, making propagation to slaves / AOF consistent.     * See issue #1525 on Github for more information. */    now = server.lua_caller ? server.lua_time_start : mstime();    /* If we are running in the context of a slave, return ASAP:     * the slave key expiration is controlled by the master that will     * send us synthesized DEL operations for expired keys.     *     * Still we try to return the right information to the caller,     * that is, 0 if we think the key should be still valid, 1 if     * we think the key is expired at this time. */    if (server.masterhost != NULL) return now > when;    /* Return when this key has not expired */    if (now <= when) return 0;    /* Delete the key */    server.stat_expiredkeys++;    propagateExpire(db,key);    notifyKeyspaceEvent(REDIS_NOTIFY_EXPIRED,        "expired",key,db->id);    return dbDelete(db,key);}/*----------------------------------------------------------------------------- * Expires Commands *----------------------------------------------------------------------------*//* This is the generic command implementation for EXPIRE, PEXPIRE, EXPIREAT * and PEXPIREAT. Because the commad second argument may be relative or absolute * the "basetime" argument is used to signal what the base time is (either 0 * for *AT variants of the command, or the current time for relative expires). * * unit is either UNIT_SECONDS or UNIT_MILLISECONDS, and is only used for * the argv[2] parameter. The basetime is always specified in milliseconds. */void expireGenericCommand(redisClient *c, long long basetime, int unit) {    robj *key = c->argv[1], *param = c->argv[2];    long long when; /* unix time in milliseconds when the key will expire. */    if (getLongLongFromObjectOrReply(c, param, &when, NULL) != REDIS_OK)        return;    if (unit == UNIT_SECONDS) when *= 1000;    when += basetime;    /* No key, return zero. */    if (lookupKeyRead(c->db,key) == NULL) {        addReply(c,shared.czero);        return;    }    /* EXPIRE with negative TTL, or EXPIREAT with a timestamp into the past     * should never be executed as a DEL when load the AOF or in the context     * of a slave instance.     *     * Instead we take the other branch of the IF statement setting an expire     * (possibly in the past) and wait for an explicit DEL from the master. */    if (when <= mstime() && !server.loading && !server.masterhost) {        robj *aux;        redisAssertWithInfo(c,key,dbDelete(c->db,key));        server.dirty++;        /* Replicate/AOF this as an explicit DEL. */        aux = createStringObject("DEL",3);        rewriteClientCommandVector(c,2,aux,key);        decrRefCount(aux);        signalModifiedKey(c->db,key);        notifyKeyspaceEvent(REDIS_NOTIFY_GENERIC,"del",key,c->db->id);        addReply(c, shared.cone);        return;    } else {        setExpire(c->db,key,when);        addReply(c,shared.cone);        signalModifiedKey(c->db,key);        notifyKeyspaceEvent(REDIS_NOTIFY_GENERIC,"expire",key,c->db->id);        server.dirty++;        return;    }}void expireCommand(redisClient *c) {    expireGenericCommand(c,mstime(),UNIT_SECONDS);}void expireatCommand(redisClient *c) {    expireGenericCommand(c,0,UNIT_SECONDS);}void pexpireCommand(redisClient *c) {    expireGenericCommand(c,mstime(),UNIT_MILLISECONDS);}void pexpireatCommand(redisClient *c) {    expireGenericCommand(c,0,UNIT_MILLISECONDS);}void ttlGenericCommand(redisClient *c, int output_ms) {    long long expire, ttl = -1;    /* If the key does not exist at all, return -2 */    if (lookupKeyRead(c->db,c->argv[1]) == NULL) {        addReplyLongLong(c,-2);        return;    }    /* The key exists. Return -1 if it has no expire, or the actual     * TTL value otherwise. */    expire = getExpire(c->db,c->argv[1]);    if (expire != -1) {        ttl = expire-mstime();        if (ttl < 0) ttl = 0;    }    if (ttl == -1) {        addReplyLongLong(c,-1);    } else {        addReplyLongLong(c,output_ms ? ttl : ((ttl+500)/1000));    }}void ttlCommand(redisClient *c) {    ttlGenericCommand(c, 0);}void pttlCommand(redisClient *c) {    ttlGenericCommand(c, 1);}void persistCommand(redisClient *c) {    dictEntry *de;    de = dictFind(c->db->dict,c->argv[1]->ptr);    if (de == NULL) {        addReply(c,shared.czero);    } else {        if (removeExpire(c->db,c->argv[1])) {            addReply(c,shared.cone);            server.dirty++;        } else {            addReply(c,shared.czero);        }    }}

#define ACTIVE_EXPIRE_CYCLE_SLOW_TIME_PERC 25 /* CPU max % for keys collection */  ...  timelimit = 1000000*ACTIVE_EXPIRE_CYCLE_SLOW_TIME_PERC/server.hz/100;  

# Redis calls an internal function to perform many background tasks, like  # closing connections of clients in timeout, purging expired keys that are  # never requested, and so forth.  #  # Not all tasks are performed with the same frequency, but Redis checks for  # tasks to perform according to the specified "hz" value.  #  # By default "hz" is set to 10. Raising the value will use more CPU when  # Redis is idle, but at the same time will make Redis more responsive when  # there are many keys expiring at the same time, and timeouts may be  # handled with more precision.  #  # The range is between 1 and 500, however a value over 100 is usually not  # a good idea. Most users should use the default of 10 and raise this up to  # 100 only in environments where very low latency is required.  hz 10  # MAXMEMORY POLICY: how Redis will select what to remove when maxmemory  # is reached. You can select among five behaviors:  #  # volatile-lru -> remove the key with an expire set using an LRU algorithm  # allkeys-lru -> remove any key according to the LRU algorithm  # volatile-random -> remove a random key with an expire set  # allkeys-random -> remove a random key, any key  # volatile-ttl -> remove the key with the nearest expire time (minor TTL)  # noeviction -> don't expire at all, just return an error on write operations  #  # Note: with any of the above policies, Redis will return an error on write  #       operations, when there are no suitable keys for eviction.  #  #       At the date of writing these commands are: set setnx setex append  #       incr decr rpush lpush rpushx lpushx linsert lset rpoplpush sadd  #       sinter sinterstore sunion sunionstore sdiff sdiffstore zadd zincrby  #       zunionstore zinterstore hset hsetnx hmset hincrby incrby decrby  #       getset mset msetnx exec sort  #  # The default is:  #  maxmemory-policy noeviction  # LRU and minimal TTL algorithms are not precise algorithms but approximated  # algorithms (in order to save memory), so you can tune it for speed or  # accuracy. For default Redis will check five keys and pick the one that was  # used less recently, you can change the sample size using the following  # configuration directive.  #  # The default of 5 produces good enough results. 10 Approximates very closely  # true LRU but costs a bit more CPU. 3 is very fast but not very accurate.  #  maxmemory-samples 5