How to implement Redis transactions

ACID attribute description

Atomicity

All operations in the transaction are inseparable in the database, either all are completed or none are executed.

Consistency

The execution of a transaction converts data from one state to another. Before the transaction starts and after the transaction ends, the integrity constraints of the database are not violated.

Isolation

The isolation of a transaction requires that the objects of each read-write transaction are separated from the operation objects of other transactions, that is, the transaction is not visible to other transactions before it is submitted.

Durability

After the database executes a transaction, the data modifications must be persisted. When the database is restarted, the value of the data needs to be the modified value.

How Redis implements transactions

Implementation principle

The execution of Redis transactions includes three steps, as follows:

• Customer The end uses the MULTI command to explicitly start a transaction.

• The server receives the specific operations sent by the client (such as adding, deleting, and modifying data) and executes them in the transaction. These operations are the data read and write commands provided by Redis itself. Although these commands are sent to the server by the client, the Redis instance only temporarily stores these commands in a command queue and does not execute them immediately.

• Only when an EXEC command is received and executed, Redis will commit the transaction and actually execute all commands in the transaction queue.

Transaction related commands

• MULTI: Open transaction

• EXEC: Submit transaction and execute command All operation commands in the queue.

• DISCARD: Abandon a transaction and clear the command queue, but the rollback of the transaction cannot be supported.

• WATCH: Detect whether the value of one or more keys changes during the execution of the transaction. If it changes, then the current transaction abandons execution.

How does Redis transaction support ACID

Does Redis transaction support atomicity?

• Scenario 1: An error is reported when executing the transaction when it is enqueued, then Redis will give up transaction execution to ensure transaction atomicity.

• Scenario 2: The command does not report an error when it is entered into the queue, but an error is reported when it is actually executed. The atomicity of the transaction cannot be guaranteed.

Example description of case one

127.0.0.1:6379> multi
OK
127.0.0.1:6379> set t1 v1
QUEUED
127.0.0.1:6379> set t2 v2
QUEUED
127.0.0.1:6379> setget t3
(error) ERR unknown command 'setget'
127.0.0.1:6379> set t4 v4
QUEUED
127.0.0.1:6379> exec
(error) EXECABORT Transaction discarded because of previous errors.
127.0.0.1:6379> get t4
(nil)

Explanation: Before executing the exec command, if a syntax error occurs (a non-existent command is used), then when the command is enqueued, Redis will report an error and record the error. After the Exec command is executed, Redi will reject all submitted commands and the transaction execution will fail. In this case, Reid's transaction can support atomicity.

Example description of case two

127.0.0.1:6379> multi 
OK
127.0.0.1:6379> incr s2
QUEUED
127.0.0.1:6379> set a1 v1
QUEUED
127.0.0.1:6379> set a2 v2
QUEUED
127.0.0.1:6379> exec
1) (error) ERR value is not an integer or out of range
2) OK
3) OK
127.0.0.1:6379> get a2
"v2"

Explanation: The value of s2 is v2, and an error is reported when executing the incr command, because incr can only add integer type values, but in this case we found The Redis transaction is not rolled back, and subsequent commands can be executed successfully, so the atomicity of the transaction cannot be guaranteed in this case.

Does Redis transaction support consistency?

Scenario 1: An error is reported when the command is added to the queue

In the first case, the transaction itself will be abandoned, so the consistency of the transaction can be guaranteed.

Case 2: No error is reported when the command is added to the queue, but an error is reported when actually executed.

In the second case, the erroneous command will not be executed, but the correct command can be executed normally, and no error is reported when the command is executed. Will change the consistency of the database.

Scenario 3: Exec execution command Redis instance fails

• If Redis persistence is set to RDB, the RDB snapshot generated will not be executed when the transaction is executed, so the transaction The results of the command operation will not be saved to the RDB snapshot. When using the RDB snapshot for recovery, the data in the database will be consistent.

• If Reids persistence is set to AOF and the instance fails before the transaction operation is recorded in the AOF log, then the database data restored using the AOF log is consistent . If only some operations are recorded in the AOF log, we can use redis-check-aof to clear the completed operations in the transaction, and the database will be consistent after recovery.

Does Redis transaction support isolation?

In order to achieve Redis transaction isolation, you need to use the watch command. The principle of Watch is that when monitoring changes in one or more keys before a transaction is executed, when the transaction calls the EXEC command to execute, the WATCH mechanism will first check whether the monitored keys have been modified by other clients. If the value of the listener is modified, transaction execution is abandoned to prevent the isolation of the transaction from being destroyed.

Example Description

Client 1:

127.0.0.1:6379> get blance
"100"
127.0.0.1:6379> watch blance
OK
127.0.0.1:6379> multi
OK
127.0.0.1:6379> decrby blance 10
QUEUED
127.0.0.1:6379> incrby blance 10
QUEUED
127.0.0.1:6379> exec
(nil)

Client 2:

127.0.0.1:6379> get blance
"100"
127.0.0.1:6379> set blance 90
OK
127.0.0.1:6379> get blance
"90"

Description: Client 1 uses watch to detect balance, after opening the transaction , perform the operation of changing the value of balance on client 2, simulate other clients changing the data monitored by the watch during transaction execution, and then execute the EXEC command of client 1, and find that the transaction was not successfully executed.

Does Redis transaction support persistence?

Redis transactions cannot support persistence. If Redis uses RDB mode, after a transaction is executed, but before the next RDB snapshot is executed, Redis instance crashes. In this case, the transaction Modified data cannot be guaranteed to be durable. If Redis adopts the AOF mode, data loss may occur regardless of whether the persistence configuration is no, everysec or always. Therefore, no matter which persistence mode Redis adopts, the durability of the transaction will be affected. Unable to support.

The above is the detailed content of How to implement Redis transactions. For more information, please follow other related articles on the PHP Chinese website!