How to implement Redis transactions
- 王林forward
- 2023-05-26 12:31:391295browse
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!