Shulou(Shulou.com)06/01 Report--

The editor will share with you the analysis of the principle and implementation of redis. I hope you will gain a lot after reading this article. Let's discuss it together.

1 what is redis

Redis is a nosql (also a huge map) single thread, but can handle concurrency of 1 second and 10w (the data is all in memory)

Using java to operate on redis is similar to the jdbc interface standard for mysql, there are all kinds of implementation classes that implement it, and the one we often use is druid

For redis, we usually use Jedis (connection pool JedisPool is also provided for us)

In redis, key is byte [] (string)

Data structure of redis (value):

String,list,set,orderset,hash

2 use of redis

Install redis, then run it, introduce dependencies in the pom file, and configure the fully qualified name of redis in the mapper.xml file of the class you want to use redis cache. Bring in the redis.properties file of redis (you can use it if you want to change the configuration)

Application scenarios:

String:

1 store json type objects, 2 counters, 3 Youku video likes, etc.

List (two-way linked list)

1 you can use redis's list to simulate queues, heaps, stacks

2 likes on moments (a statement on the content of moments, several words of praise)

Rules: the format of the content in moments:

1, content: user:x:post:x content to store

2, like: post:x:good list to store; (take out the corresponding avatar to display)

Hash (hashmap)

1 Save object

2 grouping

3 data difference between string and hash

In network transmission, serialization must be carried out before network transmission can be carried out, so when using the type of string type, you need to carry out related serialization, and hash also needs to carry out related serialization, so there will be a lot of serialization. Hash can be stored more richly when it is stored, but when deserialization, string deserialization is relatively low. The serialization and deserialization of hash is more complex than the hash class, so if you look at the business scenario, if the data is frequently modified, you can use string for performance, and if the data is not often changed, you can use hash. Because of hash, you can store a variety of data types.

4 persistence method of redis:

Yes, data in memory can be asynchronously written to the hard disk in two ways: RDB (default) and AOF

RDB persistence principle: triggered by the bgsave command, then the parent process executes the fork operation to create the child process, the child process creates the RDB file, generates a temporary snapshot file according to the memory of the parent process, and then atomic replaces the original file (regularly snapshots all the data at once to generate a copy and stores it on the hard disk)

Pros: it is a compact, compressed binary file, and Redis loads RDB to recover data much faster than AOF.

Disadvantages: non-real-time persistence due to the high cost of generating RDB each time

AOF persistence principle: when turned on, every time Redis executes a command to modify data, it will add this command to the AOF file.

Advantages: real-time persistence.

Disadvantages: so the size of the AOF file is getting larger and larger, and regular rewrite operations are needed to reduce the file size and load slowly.

Why is 5 redis single thread so fast?

Redis is single-threaded, but why is it still so fast

Reason 1: single thread to avoid competition between threads

Reason 2: is in memory, using memory, can reduce the io of the disk

Reason 3: multiplexing model, using the concept of buffer, selector model to carry out

6. How to operate when the redis master has failed?

Redis provides Sentinel mode, which can be replaced by others when the master is dead. The implementation principle of Sentinel mode is three scheduled task monitoring.

6.1 every 10 seconds, each S node (Sentinel node) sends info commands to the master and slave nodes to get the latest topology

6.2 every 2s, each S node will send to a channel the S node's judgment of the master node and the information of the current Sl node.

At the same time, each Sentinel node will also subscribe to this channel to learn about other S nodes and their judgment of the master node (as an objective offline basis)

6.3 every 1s, each S node sends a ping command to the master node, slave node and other S nodes to do heartbeat detection (heartbeat detection mechanism) to confirm whether these nodes are currently reachable.

When the heartbeat is tested for three times, the vote will be held, and when more than half of the time, the node will be taken as the decision.

7 redis Cluster

Redis cluster provides ruby script to build after 3. 0, introducing rough concepts.

Nodes in Redis cluster communicate with each other through ping/pong messages, which can propagate not only node slot information, but also other states such as master-slave state, node failure and so on. Therefore, fault detection is also realized through message propagation mechanism, and the main links include: subjective referral (pfail) and objective referral (fail).

Subjective and objective offline:

Subjective offline: each node in the cluster periodically sends ping messages to other nodes, and the receiving node responds with pong messages. If the communication continues to fail, the sending node marks the receiving node as a subjective offline (pfail) state.

Objective offline: more than half of the primary node is objectively offline.

The master node elects a master node as the leader to fail over.

Failover (electing the slave node as the new master node)

8 memory elimination strategy

Redis's memory elimination strategy refers to how to deal with data that requires new writes and requires additional space when Redis runs out of memory for caching.

Noeviction: when there is not enough memory to hold new write data, the new write operation reports an error.

Allkeys-lru: when there is not enough memory to hold newly written data, remove the least recently used key in the key space.

Allkeys-random: when there is not enough memory to hold newly written data, a key is randomly removed in the key space.

Volatile-lru: when there is not enough memory to hold newly written data, remove the least recently used key from the key space where the expiration time is set.

Volatile-random: when there is not enough memory to hold newly written data, a key is randomly removed from the key space where the expiration time is set.

Volatile-ttl: when there is not enough memory to hold newly written data, key with an earlier expiration time is removed first in the key space where the expiration time is set.

9 solution to cache breakdown:

Reason: when others request data, a lot of data cannot be queried in the cache, so it goes directly to the data query.

The solution is that the data querying the relevant data can only query the cache, and if it is special, it can be queried in the database.

You can also use Bloom filter to query.

10 solution to cache avalanche:

Cause of cache avalanche: too much data is added to the cache at one time, resulting in too much memory, which affects the use of memory and leads to service downtime.

Solution:

1 redis cluster to place data in a cluster manner

2 backend service degradation and flow restriction: when an interface requests too many times, too much data will be added, and the service can be limited and the number of visits can be limited, thus reducing the occurrence of problems.

After reading this article, I believe you have a certain understanding of the analysis of redis principles and implementation methods, want to know more related knowledge, welcome to follow the industry information channel, thank you for reading!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.