This article brings you relevant knowledge about Redis, which mainly introduces the relevant content about common data structures. There are five most commonly used ones, namely string, hash, Let’s take a look at lists, sets and ordered sets. I hope it will be helpful to everyone.
Recommended learning: Redis video tutorial
Redis common data structures
Redis provides some data structures for When we access data in Redis, there are five most commonly used ones: String, Hash, list, set, and ordered set (ZSET).
String (String)
The string type is the most basic data structure of Redis. First of all, the keys are all string types, and several other data structures are built on the basis of the string type, so the string type can lay the foundation for the learning of the other four data structures. The value of the string type can actually be a string (simple string, complex string (such as JSON, XML)), number (integer, floating point number), or even binary (picture, audio, video), but the value is the largest Cannot exceed 512MB.
(Although Redis is written in C, there are strings in C which are essentially implemented using char arrays. However, due to various considerations, Redis still implements the string type itself)
Operation command
set set value
set key value
The set command has several options:
ex seconds: Set the second-level expiration time for the key.
px milliseconds: Set the millisecond expiration time for the key.
nx: The key must not exist before it can be set successfully and is used for adding (commonly used for distributed locks).
xx: Contrary to nx, the key must exist before it can be set successfully and used for update.
From the execution effect, the ex parameter is basically the same as the expire command. Another thing that needs special attention is that if a string has an expiration time set, and then you call the set method to modify it, its expiration time will disappear.
The execution effects of nx and xx are as follows
In addition to the set option, Redis also provides two commands: setex and setnx:
setex key
seconds value
setnx key value
The functions of setex and setnx are the same as the ex and nx options. That is, setex sets the second-level expiration time for the key. The key must not exist when setnx is set before it can be set successfully.
setex example:
##setnx example:
Because key foo-ex already exists, So setnx fails and the return result is 0. The key foo-ex2 does not exist, so setnx succeeds and the return result is 1.
Are there any application scenarios? Take the setnx command as an example. Due to the single-threaded command processing mechanism of Redis, if multiple clients execute setnx key value at the same time, only one client can set it successfully according to the characteristics of setnx. , setnx can be used as an implementation solution for distributed locks. Of course, distributed locking does not require just one command. There are many things to pay attention to. We will use a separate chapter to describe distributed locking based on Redis later.
get Get the value
If the key to be obtained does not exist, return nil (empty):
mset Set values in batches
Set 4 key-value pairs at one time through the mset command
mget Get values in batches
Obtained the values of keys a, b, c, d in batches:
If some keys do not exist, then their values are nil (null), the results are returned in the order of the input keys.
Batch operation commands can effectively improve efficiency. If there is no command like mget, the specific time required to execute n get commands is as follows:
n times get time = n times network time n times commands Time
After using the mget command, the specific time required to execute n get command operations is as follows:
n times get time = 1 time network time n times command time
Redis can support tens of thousands of read and write operations per second, but this refers to the processing capability of the Redis server. For the client, in addition to the command time, a command also has network time. Assuming that the network time is 1 millisecond, the command The time is 0.1 milliseconds (based on processing 10,000 commands per second), then it takes 1.1 seconds to execute 1,000 get commands (10001 10000.1=1100ms), and 1 mget command takes 0.101 seconds (1 1 10000.1=101ms).
Incr Numerical Operations
The incr command is used to perform increment operations on values. The returned results are divided into three situations:
The value is not an integer, Return an error.
The value is an integer, and the result after auto-increment is returned.
The key does not exist. It will be incremented according to the value of 0 and the returned result will be 1.
In addition to the incr command, Redis provides decr (self-decrement), incrby (self-increment specified number), decrby (self-decrement specified number), incrbyfloat (self-increasing floating point number) ), students are asked to try it on their own for specific effects.
append append command
append can append a value to the end of the string
strlen string Length
Return string length
Note: Each Chinese character occupies 3 bytes
getset setting And return the original value
getset will set the value just like set, but the difference is that it will also return the original value of the key
setrange sets the characters at the specified position
The subscript starts from 0.
getrange intercepts a string
getrange intercepts a part of the string to form a substring. You need to specify the start and end offsets. The intercepted range is a closed interval.
Time complexity of the command
String Among these commands, except del, mset, mget support batches of multiple keys Operation, the time complexity is related to the number of keys, which is O(n). Getrange is related to the string length, which is also O(n). The rest of the commands basically have a time complexity of O(1), in terms of speed. Still very fast.
Usage scenarios
The string type has a wide range of usage scenarios:
Cache function
Redis As the cache layer, MySQL serves as the storage layer, and most of the requested data is obtained from Redis. Since Redis has the characteristics of supporting high concurrency, caching can usually play a role in accelerating reading and writing and reducing back-end pressure.
Counting
Using Redis as the basic tool for counting, it can realize the functions of fast counting and query caching, and the data can be asynchronously landed to other data sources.
Shared Session
A distributed Web service saves the user's Session information (such as user login information) in their respective servers. This will cause a problem. For load balancing considerations, distributed services will balance user access to different servers. Users who refresh their access may find that they need to log in again. This problem is intolerable to users.
In order to solve this problem, you can use Redis to centrally manage the user's Session. In this mode, as long as Redis is highly available and scalable, every time the user updates or queries login information, it will be directly accessed from Centralized acquisition in Redis.
speed limit
For example, for security reasons, many applications will ask users to enter a mobile phone verification code every time they log in to determine whether they are the user. myself. However, in order to prevent the SMS interface from being accessed frequently, the frequency of users obtaining verification codes per minute will be limited, for example, no more than 5 times per minute. Some websites restrict an IP address from being asked more than n times in one second, and a similar idea can be adopted.
Hash
Java provides HashMap, and Redis also has a similar data structure, which is the hash type. But please note that the mapping relationship in the hash type is called field-value. Note that the value here refers to the value corresponding to the field, not the value corresponding to the key.
Operation command
Basically, the hash operation command is very similar to the string operation command. Many commands add the letter h in front of the string type command, which means it is an operation. Greek type, and also specify the value of the field to be operated on.
hset set value
hset user:1 name lijin
If the setting is successful, 1 will be returned, otherwise 0 will be returned. In addition, Redis provides the hsetnx command. Their relationship is the same as the set and setnx commands, except that the scope changes from key to field.
hget value
hget user:1 name
If the key or field does not exist, nil will be returned.
hdel delete field
hdel will delete one or more fields, and the return result is the number of successfully deleted fields.
hlen calculates the number of fields
hmset sets values in batches
hmget batch value
##hexists determine whether the field exists
If it exists, return 1, if it does not exist, return 1 Returns 0
hkeys gets all fields
It returns all fields with the specified hash key
hvals gets all values
hgetall gets all fields and values
When using hgetall, if the number of hash elements is large, Redis will be blocked. possible. If you only need to get part of the field, you can use hmget. If you must get all the field-values, you can use the hscan command. This command will progressively traverse the hash type. hscan will be introduced in a later chapter.
hincrby adds
hincrby and hincrbyfloat, just like the incrby and incrbyfloat commands, but their scope is filed.
hstrlen Calculates the string length of value
Time complexity of the command
In hash type operation commands, hdel, hmget , the time complexity of hmset is related to the number of fields carried by the command, O(k), hkeys, hgetall, hvals is related to the total number of fields stored, O(N). The time complexity of the rest of the commands is O(1).
Usage scenarios
As can be seen from the previous operations, the operations of String and Hash are very similar, so why do you need to create a hash for storage.
The hash type is more suitable for storing object type data. We can compare it. If the user recorded in the database table is:
id | name | age |
##1
| lijin |
18 |
|
2
| msb |
20 |
|
1. Using the String type
requires inserting and retrieving one by one.
set user:1:name lijin;
set user:1:age 18;
set user:2:name msb;
set user :2:age 20;
Advantages: simple and intuitive, each key corresponds to a value
Disadvantages: too many keys, taking up a lot of memory, user The information is too scattered and cannot be used in the production environment
2. Serialize the object and store it in redis
set user:1 serialize(userInfo);
Advantages: Simple programming, reasonable memory usage if serialization is used
Disadvantages: Serialization and deserialization have a certain overhead, userInfo needs to be updated when updating attributes Take it all out and deserialize it, update it and then serialize it to redis
3. Use hash type
hmset user:1 name lijin age 18
hmset user:2 name msb age 20
Advantages: simple and intuitive, reasonable use can reduce memory space consumption
Disadvantage: need to control Internal encoding format, inappropriate format will consume more memory
List (list)
The list (list) type is used to store multiple ordered strings, a The four elements , b, c, c, and b form an ordered list from left to right. Each string in the list is called an element. A list can store up to (2^32-1) Element(4294967295).
In Redis, you can insert (push) and pop (pop) both ends of the list, you can also get a list of elements in a specified range, get elements with a specified index subscript, etc. . List is a relatively flexible data structure that can act as a stack and queue and has many application scenarios in actual development.
The list type has two characteristics:
First, the elements in the list are ordered, which means that an element can be obtained through the index subscript Or a list of elements within a range.
Second, the elements in the list can be repeated.
Operation command
lrange Gets a list of elements within the specified range (elements will not be deleted)
key start end
Index subscript features: from left To the right is 0 to N-1
lrange 0 -1 command can get all elements of the list from left to right
rpush insert to the right
lpush Insert to the left
linsert Insert before or after an element New element
The three return results are the length of the current list after the command is completed, also It is the number of elements contained in the list. At the same time, both rpush and lpush support inserting multiple elements at the same time.
lpop pops from the left side of the list (elements will be deleted)
r
Please note that the elements will disappear after popping up.
rpop Pop from the right side of the list
rpop will pop the element d on the far right side of the list.
lrem Delete the specified element
lrem command will find the element equal to value from the list and delete it. There are three situations according to the count:
count>0, from left to right, delete up to count elements.
count
count=0, delete all.
The return value is the number of elements actually deleted.
ltirm Trim the list according to the index range
For example, if you want to retain the 0th to 1st elements in the list
ls
lset modify the specification The element at the index subscript
lindex Gets the element at the specified index subscript of the list
l
llen Gets the length of the list
blpop and brpop blocking pop-up elements
blpop and brpop are blocking versions of lpop and rpop. In addition, they also support multiple list types and settings. Set the blocking time in seconds. If the blocking time is 0, it means it will continue to block. Let's take brpop as an example.
A client is blocked (because it will block if there is no element)
A client has been blocked . At this time, we execute
from another client B. Client A will output
. Note: If after brpop If there are multiple keys, then brpop will traverse the keys from left to right. Once a key can pop up the element, the client will return immediately.
Usage Scenarios
The list type can be used for example:
Message queue, Redis's lpush brpop command combination can achieve blocking queue, the producer client uses lrpush from the list Insert elements on the left, and multiple consumer clients use the brpop command to "grab" elements at the end of the list in a blocking manner. Multiple clients ensure load balancing and high availability of consumption.
Article List
Each user has his or her own article list, and now the article list needs to be displayed in pages. At this time, you can consider using a list, because the list is not only ordered, but also supports obtaining elements according to the index range.
Implement other data structures
lpush lpop =Stack(stack)
lpush rpop =Queue(queue)
lpsh ltrim =Capped Collection(limited collection )
lpush brpop=Message Queue(Message Queue)
SET
The set type is also used to save Multiple string elements, but unlike the list type, duplicate elements are not allowed in the set, and the elements in the set are unordered, and the elements cannot be obtained through index subscripts.
A collection can store up to 2 to the 32nd power - 1 element. In addition to supporting addition, deletion, modification, and query within a collection, Redis also supports intersection, union, and difference sets of multiple collections. Proper use of collection types can solve many practical problems in actual development.
In-set operation command
sadd Add element
You can add multiple elements, and the return result is the number of successfully added elements
srem Delete elements
Allows to delete multiple elements, the return result is the number of successfully deleted elements
scard Calculate the number of elements
sismember determines whether the element is in the set
If the given element element is in the set, it returns 1, otherwise it returns 0
srandmember Randomly returns the specified number of elements from the collection
If the specified number is not written, the default is 1
spop randomly pops elements from the collection
You can also specify the number. If not written, the default is 1. Note that since it is popping, after the spop command is executed, the elements will be deleted from the collection, but srandmember will not .
smembers Get all elements (no elements will pop out)
The return result is unordered
##Inter-set operation commandNow there are two sets, they are set1 and set2
##sinter Find the intersection of multiple sets
suinon Find the union of multiple sets
sdiff Find the difference of multiple sets
Save the results of intersection, union, and difference sets
sinterstore destination key [key ...]
suionstore destination key [key ...]
sdiffstore destination key [key ...]复制代码
The operations between sets will be more time-consuming when there are many elements, so Redis provides the above three commands ( The original command store) saves the results of intersection, union, and difference between sets in the destination key, for example:
Usage scenario
Comparison of set types A typical usage scenario is tags. For example, one user may be interested in entertainment and sports, while another user may be interested in history and news. These points of interest are tags. With this data, you can get the people who like the same tag and the tags that users like in common. This data is important for user experience and enhancing user stickiness.
For example, an e-commerce website will make different types of recommendations to users with different labels. For example, for people who are more interested in digital products, the latest digital products will be recommended to them on various pages or through emails. Usually it will bring more benefits to the website.
In addition, collections can also generate random numbers for activities such as lottery activities, social graphs, etc.
Ordered sets (ZSET)
Ordered sets are a little unfamiliar compared to hashes, lists, and sets, but since they are called If an ordered set is an ordered set, then it must be related to the set. It retains the feature that the set cannot have duplicate members, but the difference is that the elements in the ordered set can be sorted. But unlike the list that uses index subscripts as the basis for sorting, it sets a score for each element as the basis for sorting.
The elements in the ordered set cannot be repeated, but the score can be repeated, just like the student numbers of students in the same class cannot be repeated, but the test scores can be the same.
Ordered sets provide functions such as obtaining specified scores and element range queries, calculating member rankings, etc. Proper use of ordered sets can help us solve many problems in actual development.
Operation commands within the collection
zadd adds members
The return result represents the number of successfully added members
To Note:
zadd command also has four options nx, xx, ch, incr. Four options
nx: member must not exist before it can be set. Success, for adding.
xx: member must exist before it can be set successfully and used for updates.
ch: Returns the number of ordered set elements and scores that have changed after this operation
incr: Increases the score, which is equivalent to the zincrby introduced later
zcard Calculate the number of members
zscore Calculate the score of a member
If the member does not exist, return nil
zrank calculates the ranking of members
zrank是从分数从低到高返回排名
zrevrank反之
很明显，排名从0开始计算。
zrem 删除成员
允许一次删除多个成员。
返回结果为成功删除的个数。
zincrby 增加成员的分数
zrange和zrevrange返回指定排名范围的成员
有序集合是按照分值排名的，zrange是从低到高返回,zrevrange反之。如果加上
withscores选项，同时会返回成员的分数
zrangebyscore返回指定分数范围的成员
zrangebyscore key min max [withscores] [limit offset count]
zrevrangebyscore key max min [withscores][limit offset count]复制代码
其中zrangebyscore按照分数从低到高返回，zrevrangebyscore反之。例如下面操作从低到高返回200到221分的成员，withscores选项会同时返回每个成员的分数。
同时min和max还支持开区间(小括号）和闭区间(中括号)，-inf和+inf分别代表无限小和无限大:
zcount 返回指定分数范围成员个数
zcount key min max
zremrangebyrank 按升序删除指定排名内的元素
zremrangebyrank key start end
zremrangebyscore 删除指定分数范围的成员
zremrangebyscore key min max
集合间操作命令
zinterstore 交集
zinterstore
这个命令参数较多，下面分别进行说明
destination:交集计算结果保存到这个键。
numkeys:需要做交集计算键的个数。
key [key ...]:需要做交集计算的键。
weights weight
[weight ...]:每个键的权重，在做交集计算时，每个键中的每个member 会将自己分数乘以这个权重,每个键的权重默认是1。
aggregate sum/
min |max:计算成员交集后，分值可以按照sum(和)、min(最小值)、max(最大值)做汇总,默认值是sum。
不太好理解，我们用一个例子来说明。（算平均分）
zunionstore 并集
该命令的所有参数和zinterstore是一致的，只不过是做并集计算，大家可以自行实验。
使用场景
有序集合比较典型的使用场景就是排行榜系统。例如视频网站需要对用户上传的视频做排行榜，榜单的维度可能是多个方面的:按照时间、按照播放数量、按照获得的赞数。
持续创作，加速成长！这是我参与「掘金日新计划 · 10 月更文挑战」的第26天，点击查看活动详情
推荐学习：Redis视频教程
The above is the detailed content of Commonly used data structures in Redis (organized and shared). For more information, please follow other related articles on the PHP Chinese website!
