Set a timeout on key.
After the timeout has expired, the key will automatically be deleted.
A key with an associated timeout is often said to be volatile in Redis
terminology.
The timeout will only be cleared by commands that delete or overwrite the
contents of the key, including DEL, SET, GETSET and all the *STORE
commands.
This means that all the operations that conceptually alter the value stored at
the key without replacing it with a new one will leave the timeout untouched.
For instance, incrementing the value of a key with INCR, pushing a new value
into a list with LPUSH, or altering the field value of a hash with HSET are
all operations that will leave the timeout untouched.
The timeout can also be cleared, turning the key back into a persistent key,
using the PERSIST command.
If a key is renamed with RENAME, the associated time to live is transferred to
the new key name.
If a key is overwritten by RENAME, like in the case of an existing key Key_A
that is overwritten by a call like RENAME Key_B Key_A, it does not matter if
the original Key_A had a timeout associated or not, the new key Key_A will
inherit all the characteristics of Key_B.
Note that calling EXPIRE/PEXPIRE with a non-positive timeout or
EXPIREAT/PEXPIREAT with a time in the past will result in the key being
deleted rather than expired (accordingly, the emitted key event
will be del, not expired).
Options
The EXPIRE command supports a set of options:
NX -- Set expiry only when the key has no expiry
XX -- Set expiry only when the key has an existing expiry
GT -- Set expiry only when the new expiry is greater than current one
LT -- Set expiry only when the new expiry is less than current one
A non-volatile key is treated as an infinite TTL for the purpose of GT and LT.
The GT, LT and NX options are mutually exclusive.
Refreshing expires
It is possible to call EXPIRE using as argument a key that already has an
existing expire set.
In this case the time to live of a key is updated to the new value.
There are many useful applications for this, an example is documented in the
Navigation session pattern section below.
Differences in Redis prior 2.1.3
In Redis versions prior 2.1.3 altering a key with an expire set using a
command altering its value had the effect of removing the key entirely.
This semantics was needed because of limitations in the replication layer that
are now fixed.
EXPIRE would return 0 and not alter the timeout for a key with a timeout set.
importredis.clients.jedis.UnifiedJedis;importredis.clients.jedis.args.ExpiryOption;publicclassCmdsGenericExample{publicvoidrun(){UnifiedJedisjedis=newUnifiedJedis("redis://localhost:6379");StringdelResult1=jedis.set("key1","Hello");System.out.println(delResult1);// >>> OK
StringdelResult2=jedis.set("key2","World");System.out.println(delResult2);// >>> OK
longdelResult3=jedis.del("key1","key2","key3");System.out.println(delResult3);// >>> 2
// Tests for 'del' step.
StringexpireResult1=jedis.set("mykey","Hello");System.out.println(expireResult1);// >>> OK
longexpireResult2=jedis.expire("mykey",10);System.out.println(expireResult2);// >>> 1
longexpireResult3=jedis.ttl("mykey");System.out.println(expireResult3);// >>> 10
StringexpireResult4=jedis.set("mykey","Hello World");System.out.println(expireResult4);// >>> OK
longexpireResult5=jedis.ttl("mykey");System.out.println(expireResult5);// >>> -1
longexpireResult6=jedis.expire("mykey",10,ExpiryOption.XX);System.out.println(expireResult6);// >>> 0
longexpireResult7=jedis.ttl("mykey");System.out.println(expireResult7);// >>> -1
longexpireResult8=jedis.expire("mykey",10,ExpiryOption.NX);System.out.println(expireResult8);// >>> 1
longexpireResult9=jedis.ttl("mykey");System.out.println(expireResult9);// >>> 10
// Tests for 'expire' step.
StringttlResult1=jedis.set("mykey","Hello");System.out.println(ttlResult1);// >>> OK
longttlResult2=jedis.expire("mykey",10);System.out.println(ttlResult2);// >>> 1
longttlResult3=jedis.ttl("mykey");System.out.println(ttlResult3);// >>> 10
// Tests for 'ttl' step.
}}
packageexample_commands_testimport("context""fmt""math""time""github.com/redis/go-redis/v9")funcExampleClient_del_cmd(){ctx:=context.Background()rdb:=redis.NewClient(&redis.Options{Addr:"localhost:6379",Password:"",// no password docs
DB:0,// use default DB
})delResult1,err:=rdb.Set(ctx,"key1","Hello",0).Result()iferr!=nil{panic(err)}fmt.Println(delResult1)// >>> OK
delResult2,err:=rdb.Set(ctx,"key2","World",0).Result()iferr!=nil{panic(err)}fmt.Println(delResult2)// >>> OK
delResult3,err:=rdb.Del(ctx,"key1","key2","key3").Result()iferr!=nil{panic(err)}fmt.Println(delResult3)// >>> 2
}funcExampleClient_expire_cmd(){ctx:=context.Background()rdb:=redis.NewClient(&redis.Options{Addr:"localhost:6379",Password:"",// no password docs
DB:0,// use default DB
})expireResult1,err:=rdb.Set(ctx,"mykey","Hello",0).Result()iferr!=nil{panic(err)}fmt.Println(expireResult1)// >>> OK
expireResult2,err:=rdb.Expire(ctx,"mykey",10*time.Second).Result()iferr!=nil{panic(err)}fmt.Println(expireResult2)// >>> true
expireResult3,err:=rdb.TTL(ctx,"mykey").Result()iferr!=nil{panic(err)}fmt.Println(math.Round(expireResult3.Seconds()))// >>> 10
expireResult4,err:=rdb.Set(ctx,"mykey","Hello World",0).Result()iferr!=nil{panic(err)}fmt.Println(expireResult4)// >>> OK
expireResult5,err:=rdb.TTL(ctx,"mykey").Result()iferr!=nil{panic(err)}fmt.Println(expireResult5)// >>> -1ns
expireResult6,err:=rdb.ExpireXX(ctx,"mykey",10*time.Second).Result()iferr!=nil{panic(err)}fmt.Println(expireResult6)// >>> false
expireResult7,err:=rdb.TTL(ctx,"mykey").Result()iferr!=nil{panic(err)}fmt.Println(expireResult7)// >>> -1ns
expireResult8,err:=rdb.ExpireNX(ctx,"mykey",10*time.Second).Result()iferr!=nil{panic(err)}fmt.Println(expireResult8)// >>> true
expireResult9,err:=rdb.TTL(ctx,"mykey").Result()iferr!=nil{panic(err)}fmt.Println(math.Round(expireResult9.Seconds()))// >>> 10
}funcExampleClient_ttl_cmd(){ctx:=context.Background()rdb:=redis.NewClient(&redis.Options{Addr:"localhost:6379",Password:"",// no password docs
DB:0,// use default DB
})ttlResult1,err:=rdb.Set(ctx,"mykey","Hello",10*time.Second).Result()iferr!=nil{panic(err)}fmt.Println(ttlResult1)// >>> OK
ttlResult2,err:=rdb.TTL(ctx,"mykey").Result()iferr!=nil{panic(err)}fmt.Println(math.Round(ttlResult2.Seconds()))// >>> 10
}
usingNRedisStack.Tests;usingStackExchange.Redis;publicclassCmdsGenericExample{ [SkipIfRedis(Is.OSSCluster, Comparison.LessThan, "7.0.0")]publicvoidrun(){varmuxer=ConnectionMultiplexer.Connect("localhost:6379");vardb=muxer.GetDatabase();// Tests for 'copy' step.booldelResult1=db.StringSet("key1","Hello");Console.WriteLine(delResult1);// >>> truebooldelResult2=db.StringSet("key2","World");Console.WriteLine(delResult2);// >>> truelongdelResult3=db.KeyDelete(newRedisKey[]{"key1","key2","key3"});Console.WriteLine(delResult3);// >>> 2// Tests for 'del' step.// Tests for 'dump' step.// Tests for 'exists' step.boolexpireResult1=db.StringSet("mykey","Hello");Console.WriteLine(expireResult1);// >>> trueboolexpireResult2=db.KeyExpire("mykey",newTimeSpan(0,0,10));Console.WriteLine(expireResult2);// >>> trueTimeSpanexpireResult3=db.KeyTimeToLive("mykey")??TimeSpan.Zero;Console.WriteLine(Math.Round(expireResult3.TotalSeconds));// >>> 10boolexpireResult4=db.StringSet("mykey","Hello World");Console.WriteLine(expireResult4);// >>> trueTimeSpanexpireResult5=db.KeyTimeToLive("mykey")??TimeSpan.Zero;Console.WriteLine(Math.Round(expireResult5.TotalSeconds).ToString());// >>> 0boolexpireResult6=db.KeyExpire("mykey",newTimeSpan(0,0,10),ExpireWhen.HasExpiry);Console.WriteLine(expireResult6);// >>> falseTimeSpanexpireResult7=db.KeyTimeToLive("mykey")??TimeSpan.Zero;Console.WriteLine(Math.Round(expireResult7.TotalSeconds));// >>> 0boolexpireResult8=db.KeyExpire("mykey",newTimeSpan(0,0,10),ExpireWhen.HasNoExpiry);Console.WriteLine(expireResult8);// >>> trueTimeSpanexpireResult9=db.KeyTimeToLive("mykey")??TimeSpan.Zero;Console.WriteLine(Math.Round(expireResult9.TotalSeconds));// >>> 10// Tests for 'expire' step.// Tests for 'expireat' step.// Tests for 'expiretime' step.// Tests for 'keys' step.// Tests for 'migrate' step.// Tests for 'move' step.// Tests for 'object_encoding' step.// Tests for 'object_freq' step.// Tests for 'object_idletime' step.// Tests for 'object_refcount' step.// Tests for 'persist' step.// Tests for 'pexpire' step.// Tests for 'pexpireat' step.// Tests for 'pexpiretime' step.// Tests for 'pttl' step.// Tests for 'randomkey' step.// Tests for 'rename' step.// Tests for 'renamenx' step.// Tests for 'restore' step.// Tests for 'scan1' step.// Tests for 'scan2' step.// Tests for 'scan3' step.// Tests for 'scan4' step.// Tests for 'sort' step.// Tests for 'sort_ro' step.// Tests for 'touch' step.boolttlResult1=db.StringSet("mykey","Hello");Console.WriteLine(ttlResult1);// >>> trueboolttlResult2=db.KeyExpire("mykey",newTimeSpan(0,0,10));Console.WriteLine(ttlResult2);TimeSpanttlResult3=db.KeyTimeToLive("mykey")??TimeSpan.Zero;stringttlRes=Math.Round(ttlResult3.TotalSeconds).ToString();Console.WriteLine(Math.Round(ttlResult3.TotalSeconds));// >>> 10// Tests for 'ttl' step.// Tests for 'type' step.// Tests for 'unlink' step.// Tests for 'wait' step.// Tests for 'waitaof' step.}}
Give these commands a try in the interactive console:
Pattern: Navigation session
Imagine you have a web service and you are interested in the latest N pages
recently visited by your users, such that each adjacent page view was not
performed more than 60 seconds after the previous.
Conceptually you may consider this set of page views as a Navigation session
of your user, that may contain interesting information about what kind of
products he or she is looking for currently, so that you can recommend related
products.
You can easily model this pattern in Redis using the following strategy: every
time the user does a page view you call the following commands:
MULTI
RPUSH pagewviews.user:<userid> http://.....
EXPIRE pagewviews.user:<userid> 60
EXEC
If the user will be idle more than 60 seconds, the key will be deleted and only
subsequent page views that have less than 60 seconds of difference will be
recorded.
This pattern is easily modified to use counters using INCR instead of lists
using RPUSH.
Appendix: Redis expires
Keys with an expire
Normally Redis keys are created without an associated time to live.
The key will simply live forever, unless it is removed by the user in an
explicit way, for instance using the DEL command.
The EXPIRE family of commands is able to associate an expire to a given key,
at the cost of some additional memory used by the key.
When a key has an expire set, Redis will make sure to remove the key when the
specified amount of time elapsed.
The key time to live can be updated or entirely removed using the EXPIRE and
PERSIST command (or other strictly related commands).
Expire accuracy
In Redis 2.4 the expire might not be pin-point accurate, and it could be between
zero to one seconds out.
Since Redis 2.6 the expire error is from 0 to 1 milliseconds.
Expires and persistence
Keys expiring information is stored as absolute Unix timestamps (in milliseconds
in case of Redis version 2.6 or greater).
This means that the time is flowing even when the Redis instance is not active.
For expires to work well, the computer time must be taken stable.
If you move an RDB file from two computers with a big desync in their clocks,
funny things may happen (like all the keys loaded to be expired at loading
time).
Even running instances will always check the computer clock, so for instance if
you set a key with a time to live of 1000 seconds, and then set your computer
time 2000 seconds in the future, the key will be expired immediately, instead of
lasting for 1000 seconds.
How Redis expires keys
Redis keys are expired in two ways: a passive way and an active way.
A key is passively expired when a client tries to access it and the
key is timed out.
However, this is not enough as there are expired keys that will never be
accessed again.
These keys should be expired anyway, so periodically, Redis tests a few keys at
random amongst the set of keys with an expiration.
All the keys that are already expired are deleted from the keyspace.
How expires are handled in the replication link and AOF file
In order to obtain a correct behavior without sacrificing consistency, when a
key expires, a DEL operation is synthesized in both the AOF file and gains all
the attached replicas nodes.
This way the expiration process is centralized in the master instance, and there
is no chance of consistency errors.
However while the replicas connected to a master will not expire keys
independently (but will wait for the DEL coming from the master), they'll
still take the full state of the expires existing in the dataset, so when a
replica is elected to master it will be able to expire the keys independently,
fully acting as a master.
RESP2/RESP3 Reply
One of the following:
Integer reply: 0 if the timeout was not set; for example, the key doesn't exist, or the operation was skipped because of the provided arguments.