Red envelope rain: a wonderful encounter between redis and Lua

2018 year , Wang Sicong's

The summit meeting

, Watermelon video

Million heroes

, And then to Yingke

Cheese Superman

, Live answers are popular all over the network .

An e-commerce company I worked for also joined this upsurge , The technical team has developed the live question answering function . After the answer , The red envelope will

Red enveloped rain

The form of fall , The user clicks on the red packet falling on the screen , If you get a red envelope , The red envelope will enter the user account in the form of cash .

Red packet rain is a typical high concurrency scenario , There are a large number of requests to access the server in a short time , The technical team wants to make the system run smoothly , Red envelope grabbing is based on  

Redis + Lua  Script

The design of .

1  Overall process

Let's analyze the overall process of grabbing red envelopes  ：

• The operating system is configured with the total amount of red envelope rain activities and the number of red envelopes , Calculate the amount of each red packet in advance and store it in  Redis  in ;

• Grab the red packet rain interface , The user clicks on the red packet falling on the screen , Initiate a request to grab a red envelope ;

• TCP  After the gateway receives the request to grab the red packet , Call the question answering system to grab the red envelope  dubbo  service , The essence of red envelope service is to execute  Lua  Script , Pass the result through  TCP  The gateway returns to the front end ;

• If users get red envelopes , Asynchronous tasks will start from  Redis  in   Get the red packet information , Call the balance system , Return the amount to the user account .

2  Red envelopes  Redis  Design

There are the following rules for grabbing red envelopes ：

• Same activity , Users can only grab red envelopes once  ;

• The number of red envelopes is limited , A red packet can only be snatched by one user .

Here's the picture , We design three data types ：

• Operation pre allocation red packet list  ;

Queue element  json  data format  ：

{
    // Red envelope number
    redPacketId : '365628617880842241' 
    // Red envelope amount
    amount : '12.21'          
}


• User red packet collection record list ;

Queue element  json  data format ：

{
    // Red envelope number
    redPacketId : '365628617880842241'
    // Red envelope amount
    amount : '12.21',
    // The user id
    userId : '265628617882842248'
}


• The user's red envelope is weight proof  Hash  surface ;

Grab a red envelope  Redis  Operation process  ：

• adopt  hexist  Command to judge red packet collection record weight prevention  Hash  Has the user in the table received a red envelope  , If the user has not received a red envelope , The process continues ;

• From the operation pre allocation red packet list  rpop  Send out a red packet data  ;

• Operation red envelope receiving record weight proof  Hash  surface  , call  HSET  The command stores the user's claim record ;

• Receive the red envelope information  lpush  Enter the user's red packet collection record list .

The process of robbing red envelopes  , We need to focus on the following points  :

• Execute multiple commands , Whether atomicity can be guaranteed  ,  If a command fails , Whether you can roll back ;

• In the process of execution , High concurrency scenarios , Whether isolation can be maintained ;

• The next steps depend on the results of the previous steps .

Redis  Two modes are supported  : 

Transaction mode

  and  

Lua  Script

, Next , Let's start one by one .

3  How things work

Redis  The transaction of contains the following commands ：

A transaction consists of three phases ：

• The transaction open , Use  MULTI ,  This command marks that the client executing this command switches from the non transactional state to the transactional state  ;

• Order to join the team ,MULTI  After opening the transaction , Client commands are not immediately executed , Instead, it is put into a transaction queue  ;

• Execute a transaction or discard . If you receive  EXEC  The order of , The commands in the transaction queue will be executed  , If it is  DISCARD  The transaction is discarded .

Here is an example of a transaction .

redis> MULTI 
OK
redis> SET msg "hello world"
QUEUED
redis> GET msg
QUEUED
redis> EXEC
1) OK
1) hello world


There is a question ？ When you start a transaction ,Redis key  Can it be modified ？

During transaction execution  EXEC  Before the command  ,Redis key  It can still be modified

.

Before the transaction is opened , We can  watch  Command monitor  Redis key . Before the transaction is executed , We modify  key  value  , Transaction execution failed , return  

nil

 .

Through the example above ,watch  The command can

Achieve an effect similar to optimistic locking

 .

4  The transaction ACID

4.1  Atomicity

Atomicity means ： All operations in a transaction , Or complete it all , Or not at all , It doesn't end in the middle . An error occurred during the execution of the transaction , It will be rolled back to the state before the transaction starts , It's like this transaction has never been executed .

First example ：

In execution  EXEC  Before the command , The operation command sent by the client is wrong , such as ： Syntax error or non-existent command used .

redis> MULTI
OK
redis> SET msg "other msg"
QUEUED
redis> wrongcommand  ###  Deliberately write wrong commands
(error) ERR unknown command 'wrongcommand' 
redis> EXEC
(error) EXECABORT Transaction discarded because of previous errors.
redis> GET msg
"hello world"


In this case , We used a command that doesn't exist , Lead to team failure , The entire transaction will fail to execute  .

Second example ：

When a transaction operation is queued , The data types of the command and operation do not match  , The queue is normal , But enforcement  EXEC  Command exception  .

redis> MULTI  
OK
redis> SET msg "other msg"
QUEUED
redis> SET mystring "I am a string"
QUEUED
redis> HMSET mystring name  "test"
QUEUED
redis> SET msg "after"
QUEUED
redis> EXEC
1) OK
2) OK
3) (error) WRONGTYPE Operation against a key holding the wrong kind of value
4) OK
redis> GET msg
"after"


In this case ,Redis  In execution  EXEC  On command , If something goes wrong ,Redis  The execution of other commands will not be terminated , The transaction will not be rolled back because a command fails to execute  .

Sum up , I am right.  Redis  The understanding of transaction atomicity is as follows ：

• The order to join the team is wrong ,  Will abandon the transaction execution , Guaranteed atomicity ;

• Normal when ordered to join the team , perform  EXEC  Error after command , There is no guarantee of atomicity ;

That is to say ：

Redis  Transactions under certain conditions , It has certain atomicity

 .

4.2  Isolation,

Database isolation refers to ： The ability of a database to allow multiple concurrent transactions to read, write, and modify its data simultaneously , Isolation can prevent data inconsistency caused by cross execution when multiple transactions are executed concurrently .

Transaction isolation is divided into different levels  , Namely ：

• Uncommitted read （read uncommitted）

• Submit to read （read committed）

• Repeatable （repeatable read）

• Serialization （serializable）

First , It needs to be clear ：Redis  There is no concept of the transaction isolation level . Here we discuss  Redis  Isolation of means ：

In the concurrent scenario , Whether transactions can not interfere with each other

.

We can divide transaction execution into  

EXEC  Before the order is executed

and  

EXEC  After the execution of the command

Two phases , Discuss separately .

• EXEC  Before the order is executed

In the transaction principle section , We found that before the transaction is executed  ,Redis key  It can still be modified . here , have access to  

WATCH  Mechanism

To achieve the effect of optimistic locking .

• EXEC  After the execution of the command

because  Redis  It is a single thread that executes operation commands , EXEC  After the execution of the command ,Redis  It will ensure that all commands in the command queue are executed  .  This ensures transaction isolation .

4.3  persistence

Database persistence refers to  ： After transaction ends , Changes to data are permanent , Even if the system fails, it will not be lost .

Redis  Whether your data is persistent depends on  Redis  Persistent configuration pattern  .

• No configuration  RDB  perhaps  AOF , The durability of transactions cannot be guaranteed ;

• Used  RDB Pattern , After a transaction is executed , Next time  RDB  Before the snapshot is executed , If an instance goes down , The persistence of transactions is also not guaranteed ;

• Used  AOF  Pattern ;AOF  Three configuration options for mode  no 、everysec  There will be data loss  .always  It can ensure the persistence of transactions , But because of the poor performance , Generally, it is not recommended to use in production environment .

Sum up ,

redis  The persistence of transactions is not guaranteed

 .

4.4  Uniformity

The concept of consistency has always been puzzling , In the information I searched , There are two different definitions .

• Wikipedia

Let's first look at the definition of consistency in Wikipedia ：

Consistency ensures that a transaction can only bring the database from one valid state to another, maintaining database invariants: any data written to the database must be valid according to all defined rules, including constraints, cascades, triggers, and any combination thereof. This prevents database corruption by an illegal transaction, but does not guarantee that a transaction is correct. Referential integrity guarantees the primary key – foreign key relationship.

In this passage , The core of consistency is “

constraint

”,“

any data written to the database must be valid according to all defined rules

 ”.

How to understand constraints ？ Here we quote Zhihu question  

How to understand the internal consistency and external consistency of a database

, The ant gold dress  OceanBase  A paragraph answered by hanfusheng, a research and development expert ：

“ constraint ” The user of the database tells the database , The user requires that the data must conform to one constraint or another . When data changes , The database will check whether the data still meets the constraints , If the constraint is no longer satisfied , Then the modification operation will not occur .

The two most common types of constraints in relational databases are “ Uniqueness constraint ” and “ Integrity constraints ”, The primary key and unique key defined in the table ensure that the specified data items will never be duplicated , The referential integrity of definitions between tables also ensures the consistency of the same attribute in different tables .

“ Consistency in ACID ” It is so easy to use , It has melted into the blood of most users , Users will consciously add the necessary constraints when designing tables , The database will also strictly enforce this constraint .

therefore

The consistency of transactions is related to predefined constraints , To ensure constraints is to ensure consistency

.

Let's savor this sentence carefully ： 

This prevents database corruption by an illegal transaction, but does not guarantee that a transaction is correct

.

You may still be a little vague here , Let's take the classic

Transfer accounts

The case of .

Let's start a transaction , The initial balance on Zhang San's and Li Si's account numbers is 1000 element , And the balance field has no constraints . Zhang San transfers money to Li Si 1200 element . Zhang San's balance is updated to  -200 ,  Li Si's balance is updated to 2200.

From the application level , This matter is obviously illegal , Because in reality , The user balance cannot be less than  0 ,  But it completely follows the constraints of the database , So from the database level , This transaction still ensures consistency .

Redis  Transaction consistency of means ：Redis  The transaction complies with the constraints of the database during execution , Does not contain illegal or invalid error data .

We will discuss three abnormal scenarios respectively ：

• perform  EXEC  Before the command , The operation command sent by the client is wrong , Transaction terminated , Data consistency ;

• perform  EXEC  After the command , The data types of the command and operation do not match , The wrong command will report an error , But the transaction will not be terminated by the wrong command , But will continue to carry out . The correct command is executed normally , The wrong command reports an error , From this point of view , Data can also be consistent ;

• In the course of executing a transaction ,Redis  The service outage . Here we need to consider the persistence pattern of service configuration . No persistent memory mode ： After the service is restarted , The database does not hold data , So the data is consistent ;RDB / AOF  Pattern ：  After the service is restarted ,Redis  adopt  RDB / AOF  File recovery data , The database will be restored to a consistent state .

in summary ,

In the sense that the core of consistency is constraint ,Redis  The transaction can guarantee consistency

.

• 《 Design data-intensive applications 》

This book is a great introduction to distributed systems . There is a paragraph about... In the chapter of affairs  ACID  The explanation of ：

Atomicity, isolation, and durability are properties of the database,whereas consistency (in the ACID sense) is a property of the application. The application may rely on the database’s atomicity and isolation properties in order to achieve consistency, but it’s not up to the database alone. Thus, the letter C doesn’t really belong in ACID.

Atomicity , Isolation and persistence are attributes of the database , And consistency （ stay  ACID  In a sense ） Is the property of the application . Applications may rely on the atomicity and isolation properties of the database to achieve consistency , But it doesn't just depend on the database . therefore , Letter  C  Do not belong to  ACID .

A lot of times , The consistency that we have been struggling with , It actually means

Consistent with the real world

, Consistency in the real world is the ultimate goal of affairs .

In order to achieve consistency in the real world , The following points need to be met ：

• Guaranteed atomicity , Persistence and isolation , If none of these characteristics can be guaranteed , Then the consistency of transactions cannot be guaranteed ;

• The constraints of the database itself , For example, the string length cannot exceed the column limit or uniqueness constraint ;

• The business level also needs to be guaranteed  .

4.5  summary

We usually call it  Redis  For memory database  ,  Different from traditional relational database , In order to provide higher performance , Faster write speed , Some balance has been made between design and implementation , Not fully transactional  ACID.

Redis  The transaction of has the following characteristics ：

• Ensure isolation ;

• There is no guarantee of persistence ;

• With a certain degree of atomicity , But rollback is not supported ;

• There are differences in the concept of consistency , Suppose that the core of consistency is the semantics of constraints ,Redis  The transaction can guarantee consistency .

in addition , In the scene of grabbing red envelopes ,  Because each step depends on the result returned from the previous step , Need to pass through  watch  To achieve the optimistic lock  , From an engineering point of view , Redis  Transactions are not appropriate for this business scenario .

5 Lua  Script

5.1  brief introduction

“ Lua ”  In Portuguese it is “ The moon ” It means ,1993 From Brazil  Pontifical Catholic University  Development .

The language is designed to be embedded in applications , This provides the application with flexible extension and customization capabilities .

Lua  Scripts can be easily  C/C ++  Code calls , You can also call... In reverse  C/C++  Function of , This makes  Lua  Can be widely used in applications . Not just as an extension script , It can also be used as a normal configuration file , Instead of  XML, Ini  Etc , And it's easier to understand and maintain .

Lua  By standard  C  Written , The code is simple and beautiful , It can be compiled on almost all operating systems and platforms , function .

A complete  Lua  The interpreter is nothing but  200 k, In all script engines at the moment ,Lua  Is the fastest . It's all decided  Lua  Is the best choice for embedded scripts .

Lua  Scripts shine in the game world , It's familiar to all of you 《 A Chinese Odyssey II》,《 World of warcraft 》 Are widely used  Lua  Script .

Java  Back end engineers have been in contact with  api  gateway , such as  

Openresty

 ,

Kong

  You can see  Lua  Script shadow .

from  Redis 2.6.0  Version start , Redis Built in  Lua  Interpreter , It can be realized in  Redis  Run in  Lua  Script .

Use  Lua  The benefits of scripting  ：

• Reduce network overhead . Send multiple requests at a time in the form of scripts , Reduce network delay .

• Atomic manipulation .Redis The entire script is executed as a whole , The middle is not inserted by other commands .

• Reuse . The script sent by the client will be permanent  Redis  in , Other clients can reuse this script without having to use code to complete the same logic .

Redis Lua  Common script commands ：

5.2 EVAL  command

Command format ：

EVAL script numkeys key [key ...] arg [arg ...]


explain ：

• script
  Is the first parameter , by  Lua 5.1 Script ;

• The second parameter
  numkeys
  There are several parameters for specifying subsequent parameters  key;

• key [key ...]
  , It's the key to operate , You can specify multiple , stay  Lua  The script passes
  KEYS[1]
  , 
  KEYS[2]
  obtain ;

• arg [arg ...]
  , Parameters , stay  Lua  The script passes
  ARGV[1]
  , 
  ARGV[2]
  obtain .

Simple example ：

redis> eval "return ARGV[1]" 0 100 
"100"
redis> eval "return {ARGV[1],ARGV[2]}" 0 100 101
1) "100"
2) "101"
redis> eval "return {KEYS[1],KEYS[2],ARGV[1]}" 2 key1 key2 first second
1) "key1"
2) "key2"
3) "first"
4) "second"


So let's do that  Lua  How to call  Redis  command  , adopt

redis.call()

Here we go  Redis  command  .

redis> set mystring 'hello world'
OK
redis> get mystring
"hello world"
redis> EVAL "return redis.call('GET',KEYS[1])" 1 mystring
"hello world"
redis> EVAL "return redis.call('GET','mystring')" 0
"hello world"


5.3 EVALSHA  command

Use  EVAL  The command needs to be transmitted every time it is requested  Lua  Script  , if  Lua  The script is too long , It will not only consume network bandwidth , And it will also be good for  Redis  The performance of the .

The idea is to  Lua  The script is cached first  ,  Return to the client  Lua  The script  sha1  Abstract .  The client stores scripts  sha1  Abstract  , Every time a request is made  EVALSHA  Command is enough .

EVALSHA  The basic syntax of the command is as follows ：

redis> EVALSHA sha1 numkeys key [key ...] arg [arg ...] 


Examples are as follows ：

redis> SCRIPT LOAD "return 'hello world'"
"5332031c6b470dc5a0dd9b4bf2030dea6d65de91"
redis> EVALSHA 5332031c6b470dc5a0dd9b4bf2030dea6d65de91 0
"hello world"


5.4  Business  VS Lua  Script

By definition , Redis  The script in is itself a transaction ,  So anything that can be done in a business ,  It can also be done in scripts .  And in general ,  It's easier to use scripts , And faster .

Because the script function is  Redis 2.6  It was introduced ,  The transaction function existed earlier ,  therefore  Redis  There are two ways to deal with transactions at the same time .

However, we do not intend to remove the transaction function in a short time ,  Because transactions provide a way to ,  The way to avoid competitive conditions ,  And the implementation of the transaction itself is not complicated .

-- https://redis.io/

Lua  A script is another form of transaction , He has a certain atomicity , But when the script reports an error , Transactions are not rolled back .Lua  Scripts guarantee isolation , And it can perfectly support

The next steps depend on the results of the previous steps

.

Sum up ,Lua  Script is the best solution for the red envelope scene .

But I'm writing  Lua  Script time , Pay attention to the following two points ：

• for fear of  Redis  Blocking ,Lua  Script business logic should not be too complex and time consuming ;

• Check and test carefully  Lua  Script  , Because execution  Lua  Scripts have some atomicity , Rollback is not supported .

6  Actual combat preparation

I choose  Redisson 3.12.0  Version as  Redis  The client of , stay  Redisson  Make a thin layer of packaging based on the source code .

Create a  PlatformScriptCommand  class ,  Used to perform  Lua  Script .

//  load  Lua  Script  
String scriptLoad(String luaScript);
//  perform  Lua  Script
Object eval(String shardingkey, 
            String luaScript, 
            ReturnType returnType,
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;List<Object>&nbsp;keys,&nbsp;
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Object...&nbsp;values);
//&nbsp; adopt &nbsp;sha1&nbsp; Summary execution Lua Script
Object&nbsp;evalSha(String&nbsp;shardingkey,&nbsp;
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;String&nbsp;shaDigest,
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;List<Object>&nbsp;keys,&nbsp;
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Object...&nbsp;values);


Here's why we need to add a  shardingkey  What about parameters?  ？

because  Redis  Cluster mode , We need to locate which node performs  Lua  Script .

public int calcSlot(String key) {
    if (key == null) {
        return 0;
    }
    int start = key.indexOf('{');
    if (start != -1) {
        int end = key.indexOf('}');
        key = key.substring(start+1, end);
    }
    int result = CRC16.crc16(key.getBytes()) % MAX_SLOT;
    log.debug("slot {} for {}", result, key);
    return result;
}


7  Grab the red envelope script

Client execution  Lua  After the script, return to  json  character string .

• The user successfully grabbed the red envelope

{
    "code":"0",
    // Red envelope amount    
    "amount":"7.1",
    // Red envelope number
    "redPacketId":"162339217730846210"
}


• The user has received

{
    "code":"1"
}


• The user failed to grab the red envelope

{
    "code":"-1"
}


Redis Lua  Built in  cjson  function , be used for  json  The codec .

-- KEY[1]:  User's anti weight claim record
local userHashKey = KEYS[1];
-- KEY[2]:  Operation pre allocation red packet list
local redPacketOperatingKey = KEYS[2];
-- KEY[3]:  User's red envelope receiving record  
local userAmountKey = KEYS[3];
-- KEY[4]:  The user id
local userId = KEYS[4];
local result = {};
--  Judge whether the user has received  
if redis.call('hexists', userHashKey, userId) == 1 then
  result['code'] = '1'; 
  return cjson.encode(result);
else
   --  Get red packet data from pre allocated red packets
   local redPacket = redis.call('rpop', redPacketOperatingKey);
   if redPacket
   then
      local data = cjson.decode(redPacket);
      --  Join users ID Information
      data['userId'] = userId; 
     --  Put the user number in the de duplicated hash ,value Set as red packet number
      redis.call('hset', userHashKey, userId, data['redPacketId']);
     --   Users and red packets are placed in the consumed queue
      redis.call('lpush', userAmountKey, cjson.encode(data));
     --  The return value of successful assembly
      result['redPacketId'] = data['redPacketId'];
      result['code'] = '0';
      result['amount'] = data['amount'];
      return cjson.encode(result);
   else
      --  Failed to grab the red envelope
      result['code'] = '-1';
      return cjson.encode(result);
   end 
end


During scripting , There will inevitably be omissions , How to debug ？

I suggest combining the two methods .

• To write  junit  The test case  ;

• from  Redis 3.2  Start , Built in  Lua debugger（ abbreviation
  LDB
  ）,  have access to  Lua debugger  Yes  Lua  Script debugging .

8  Asynchronous task

stay  Redisson  Two classes are encapsulated based on  , Simplify the cost of developers .

• RedisMessageConsumer : 
  Consumer class
  , Configure listening queue name , And the corresponding consumption listener

String groupName = "userGroup";
String queueName = "userAmountQueue";
RedisMessageQueueBuilder buidler =
        redisClient.getRedisMessageQueueBuilder();
RedisMessageConsumer consumer =
        new RedisMessageConsumer(groupName, buidler);
consumer.subscribe(queueName, userAmountMessageListener);
consumer.start();


• RedisMessageListener : 
  Consumer monitor
  , Write business consumption code

public class UserAmountMessageListener implements RedisMessageListener {
  @Override
  public RedisConsumeAction onMessage(RedisMessage redisMessage) {
   try {
    String message = (String) redisMessage.getData();
    // TODO  Call the user balance system
    //  Return to consumption success
    return RedisConsumeAction.CommitMessage;
   }catch (Exception e) {
    logger.error("userAmountService invoke error:", e);
    //  Consumption failure , Perform retry operation
    return RedisConsumeAction.ReconsumeLater;
  }
 }
}


9  Wrote last

"

It's on paper ,  We must know that we must do it

" .

Study  Redis Lua  In the process , I searched a lot of information , Example by example , A lot to gain .

Very frankly  ,  Before writing this article , I am right.  Redis Lua  There's a lot of

Take it for granted

The understanding of the , such as  Redis  I'm surprised that the transaction can't be rolled back .

So when facing unfamiliar knowledge points , Don't jump to conclusions , Learn with humility , This is the mentality that an engineer needs .

meanwhile , No technology is perfect , Between design and coding , There is one balance or another , This is the real world .

If my article is helpful to you , Please help me

give the thumbs-up 、 Looking at 、 forward

once , Your support will encourage me to output higher quality articles , Thank you very much ！