Redis transaction instance analysis

Usage in Redis

Redis implements transaction functions through multi, exec, discard, and watch.

• multi: start transaction

• exec: commit transaction and execute

• discard: cancel transaction

• watch: Monitor any number of keys before the transaction starts

> multi
OK
> set bookName "Redis"
QUEUED
> get bookName
QUEUED
> sadd tag "Redis" "New Book"
QUEUED
> smembers tag
QUEUED
> exec
1) OK
2) "Redis"
3) (integer) 2
4) 1) "Redis"
   2) "New Book"

Start transaction

> multi
OK

This command turns on the Redis_multi option , let the client change from non-transactional state to transactional state

Command enqueue

> set bookName "Redis"
QUEUED
> get bookName
QUEUED
> sadd tag "Redis" "New Book"
QUEUED
> smembers tag
QUEUED

The Redis command will not be executed immediately, but will first enter an advanced First out of the transaction queue until the transaction is committed. QUEUED indicates that this command has been entered into the transaction queue.

Execute transactions

> exec
1) OK
2) "Redis"
3) (integer) 2
4) 1) "Redis"
   2) "New Book"

When executing the exec command, Redis executes the commands in the transaction queue in a first-in, first-out manner according to the transaction queue saved by the client: the first command to be queued Executed first, and the last command enqueued is executed last. After executing the exec command, Redis stores the results in the reply queue and sends the queue to the client. The client exits from the transaction state and a transaction is completed.

discard command

> multi
OK
> set author "lisi"
QUEUED
> discard
OK
> get author
(nil)

discard is a command to cancel a transaction, indicating that the transaction has been cancelled. When the client ends the transaction state and returns to the non-transaction state, the Redis_multi option needs to be turned off.

watch command

# Redis 客户端1
> watch letter
OK
> multi
OK
> set letter a
QUEUED
> exec
(nil)


# Redis 客户端2
> set letter b
OK

# Redis 客户端1
> get letter
"b"

When client 1 enters the transaction, the watch sets the letter key and sets its value to a, but the transaction has not yet submit. Client 2 sets the value of letter to b. After client 1 commits the transaction, the result returned is nil, but by calling the get command, the value of letter can be obtained as b. This means that when the letter key is changed by another client, the transaction will be canceled, will not be executed, and will fail.

The watch command monitors any number of keys before the transaction starts: when calling the excel command to execute a transaction, if any of the monitored keys has been modified by other clients, the entire transaction will no longer be executed and will return directly. fail.

Transaction exception

Command error

> set letter ac
QUEUED
> get letter ac
(error) ERR wrong number of arguments for 'get' command
> exec
(error) EXECABORT Transaction discarded because of previous errors.

Command exception in the transaction is a syntax error and will cause the transaction to fail to be executed.

Runtime exception

> multi
OK
> lpush books "Redis"
QUEUED
> incr books
QUEUED
> lpush books "Python"
QUEUED
> lrange books 0 -1
QUEUED
> exec
1) (integer) 1
2) (error) WRONGTYPE Operation against a key holding the wrong kind of value
3) (integer) 2
4) 1) "Python"
   2) "Redis"

The above example is that the transaction encountered a failure in the middle of execution, because the incr command cannot be performed on a string. After the transaction encounters a command execution failure, subsequent The command continues to execute, so the value of books continues to be set. This exception can only be avoided by programmers in their code.

ACID of transactions

Atomicity

Atomic means that either they execute successfully together or they fail together and are rolled back. All APIs provided by Redis are atomic operations. Then the Redis transaction only needs to guarantee atomicity in a batch of operations. However, in the case of runtime exceptions, if an exception occurs in a command in a transaction, other commands will continue to be executed. There is no rollback mechanism for the transaction, so the Redis transaction is not guaranteed to be atomic. sexual.

Consistency

Transaction exception

If the command error occurs, the transaction cannot be executed. If it is a runtime exception, Redis will include the error in the return result and will not affect subsequent execution. , so the transaction is consistent.

The Redis process is terminated

In pure memory mode, Redis does not perform persistence. After restarting, the database is blank, so it is transactionally consistent.

In RDB mode, the transaction will not perform the work of saving the RDB file in the middle. The RDB work may start only after the transaction is completed. Therefore, the Redis process is killed during transaction execution, and no matter how successful it is, it will not be saved to the RDB file, so it is consistent.

In AOF mode, part of the transaction statement is written to the AOF file and saved successfully. Incomplete transactions are saved to the AOF file. When restarting Redis, check that the AOF file is incomplete, and Redis exits with an error. This incomplete transaction needs to be deleted before the restart can be successful, so it is consistent.

In AOF mode, transactions are not written to the AOF file, so after restarting the Redis database is the latest data successfully saved to the AOF file. There is no data for this transaction, so it is consistent.

Isolation

Redis is a single-process program, and it guarantees that the transaction will not be interrupted when executing the transaction. The transaction can run until all commands in the transaction queue are executed. So transactions are isolated.

Persistence

In pure memory mode, transactions are definitely not persistent.

In RDB mode, the server may fail during the period after the transaction is executed and before the RDB file is updated, so transactions in RDB mode are not durable.

In AOF mode, add the command to the AOF file, but writing the file will not be written to the disk immediately, but will be stored in the buffer first. So there is a very small interval between data being saved to disk. Transactions in this mode are not durable either.

The above is the detailed content of Redis transaction instance analysis. For more information, please follow other related articles on the PHP Chinese website!