Die umfassendste und detaillierteste Erklärung von MySQL-Transaktionen

Was ist eine Transaktion?

Wie lautet der offizielle MySQL-Satz zur Beschreibung einer Transaktion? MySQL-Transaktionen werden hauptsächlich zur Verarbeitung von Daten mit großen Vorgängen und hoher Komplexität verwendet. Warum ist die Datenmenge so groß? Warum ist die Komplexität hoch? Lassen Sie es mich anhand meines eigenen Verständnisses beschreiben. Transaktionen sind eigentlich eine Methode zur Datenverarbeitung in MySQL. Sie werden hauptsächlich verwendet, wenn die Datenintegrität hoch und die Abhängigkeit zwischen Daten groß ist. Beispielsweise überwies Xiao Zhang 200 Yuan auf die Bankkarte von Xiao Li. Als Xiao Zhang auf die Schaltfläche zur Bestätigung der Überweisung klickte, stürzte das System plötzlich ab. Es wird mehrere falsche Situationen wie diese geben:

1. Xiao Zhangs Geld wurde auf Xiao Lis Konto überwiesen, aber das Geld auf seinem eigenen Konto wurde nicht abgebucht.

2

Ein solches Geschäftsszenario erfordert die Wartung von MySQL-Transaktionen.

Bedingungen für die Transaktionsnutzung

MySQL Zur Nutzung von Transaktionen ist die Storage-Engine-Unterstützung in MySQL erforderlich. Zu den integrierten Speicher-Engines von MySQL, die Transaktionen unterstützen, gehören derzeit InnoDB und NDB-Cluster, und zu den Speicher-Engines von Drittanbietern gehören PBXT und XtrDB.

Was sind die Merkmale von Transaktionen?

Transaktionen in MySQL haben die folgenden Eigenschaften (ACID):

Atomizität:

Eine Transaktion muss eine unteilbare Mindesteinheit von sein Alle Vorgänge in jeder Transaktion müssen entweder erfolgreich sein oder fehlschlagen. Es ist niemals möglich, dass einige Vorgänge fehlschlagen und einige Vorgänge erfolgreich sind.

Konsistenz:

Konsistenz ist genau wie im obigen Beispiel. Wenn eine Ausnahme auftritt, sind die Daten immer noch korrekt. Das heißt, wenn eine Transaktion fehlschlägt, werden die Daten nicht durch ungewöhnliche Situationen beeinträchtigt und behalten immer ihre Richtigkeit

Isolierung:

Wenn a Die Transaktion wurde noch nicht festgeschrieben, jede Transaktion ist voneinander isoliert und die Komplementarität ist beeinträchtigt.

Dauerhaftigkeit (Dauerhaftigkeit):

Wenn nach der Übermittlung einer Transaktion die Änderungen werden für immer in der Datenbank gespeichert.

Isolationsebene der Transaktion

Wenn wir über die Isolationseigenschaften von MySQL sprechen, müssen wir über mehrere Isolationsebenen sprechen. Der Grund dafür kann einfach wie folgt verstanden werden: Wenn es zwei Anforderungen gibt, die gleichzeitig Transaktionsvorgänge ausführen, und diese beiden Transaktionen mit denselben Daten arbeiten, dann basiert das Endergebnis darauf, wer welche soll sich durchsetzen? Unterschiedliche Isolationsstufen führen zu unterschiedlichen Ergebnissen, daher ist auch die Isolationsstufe einer Transaktion ein sehr wichtiger Punkt:

1 (READ UNCOMMITTED)

Änderungen an Daten in einer Transaktion sind für andere Transaktionen immer noch sichtbar. In diesem Fall kann es zu fehlerhaften Lesevorgängen kommen, die die Datenintegrität beeinträchtigen >

Als Xiao Ming beispielsweise mit Alipay bezahlte, überprüfte er das Guthaben seiner Bankkarte auf 300 Yuan. Tatsächlich waren es nur 100 Yuan, weil seine Freundin 200 Yuan auf die Bankkarte eingezahlt hatte. Zu diesem Zeitpunkt wollte die Freundin nicht sparen, also klickte sie auf den Rollback-Vorgang, aber Xiao Ming konnte nicht zahlen.

2. LESEN SIE VERPFLICHTET

Eine Transaktion beginnt, sind nur andere übermittelte Transaktionen sichtbar. In diesem Fall kann es leicht zu nicht wiederholbaren Ablesungen kommen (die Ergebnisse der beiden Ablesungen sind unterschiedlich). 100 Yuan, aber nachdem ich auf die endgültige Zahlung geklickt habe, wurde mir mitgeteilt, dass der Restbetrag nicht ausreichte. Zu diesem Zeitpunkt war das Geld auf der Karte aufgebraucht. Dies liegt daran, dass die von Xiao Ming durchgeführte Transaktion noch nicht eingereicht worden war, als Xiao Mings Freundin bezahlte, sodass Xiao Mings Freundin zweimal unterschiedliche Ergebnisse sah.

3. WIEDERHOLBARES LESEN

Die Ergebnisse des mehrmaligen Lesens von Datensätzen sind konsistent. Wiederholbares Lesen kann die oben genannte nicht wiederholbare Lesesituation lösen. Es gibt jedoch eine Situation, in der, wenn eine Transaktion Datensätze in einem bestimmten Bereich liest, eine andere Transaktion ein neues Datenelement in diesem Bereich einfügt. Wenn die Transaktion die Daten erneut liest, stellt sich heraus, dass die Daten größer sind als beim ersten Lesen. Es gibt noch einen weiteren Datensatz. Die Ergebnisse der beiden Lesevorgänge sind inkonsistent.

Als Xiao Mings Freundin die Bankkartenunterlagen überprüfte, sah sie 5 Verbrauchsdatensätze Diesmal war Xiao Ming Verbrauch. Als die Freundin den Datensatz erneut las, stellte sie fest, dass es 6 Datensätze gab.

4 SERIALISIERBAR

Seriell ist wie eine Warteschlange. Jede Transaktion steht in der Warteschlange und wartet auf die Ausführung. Erst nachdem die vorherige Transaktion übermittelt wurde, kann die nächste Transaktion ausgeführt werden. Obwohl diese Situation das obige Phantomlesen lösen kann, wird jedem Datenelement eine Sperre hinzugefügt, was leicht zu einer großen Anzahl von Sperrzeitüberschreitungen und Sperrkonkurrenz führen kann. Dies ist insbesondere für einige Geschäftsszenarien mit hoher Parallelität nicht geeignet.

Beispiel: Wir stehen Schlange, um Geld bei der Bank einzuzahlen. Erst wenn die vorherige Person alle Operationen abgeschlossen hat, kann die nächste Person fortfahren. Personen in der Mitte dürfen nicht in die Warteschlange springen, sie können sich nur einzeln anstellen. Die Serialisierung von Transaktionen ist tatsächlich ein solches Konzept.

Isolationszusammenfassung

Anhand der obigen Beispiele ist es für uns nicht schwer, das herauszufinden. Dirty Reads und nicht wiederholbare Lesevorgänge konzentrieren sich auf die Aktualisierung von Daten, und Phantom Reads konzentrieren sich auf das Einfügen von Daten.

Wie Transaktionen mit mehreren Speicher-Engines verarbeitet werden

Gemäß den in den oben genannten Transaktionen verwendeten Bedingungen Wir können es bekommen Es ist bekannt, dass einige Speicher-Engines keine Transaktionen unterstützen, beispielsweise die MyISAM-Speicher-Engine. Wenn in einer Transaktion eine transaktionale Speicher-Engine und eine nicht-transaktionale Speicher-Engine verwendet werden, kann das Festschreiben normal fortgesetzt werden, aber beim Zurücksetzen der nicht-transaktionalen Speicher-Engine wird eine Antwortfehlermeldung angezeigt. Die spezifischen Informationen beziehen sich auf die Speicher-Engine

So verwenden Sie Transaktionen

Transaktionen in MySQL sind implizit aktiviert, das heißt, eine SQL-Anweisung ist eine Transaktion eingereicht. Während der Demonstration haben wir explizit aktiviert.

Auto-Commit in MySQL

Wie oben erwähnt, sind Transaktionen in MySQL implizit aktiviert, was bedeutet, dass jedes Mal, wenn wir Wenn Sie es deaktivieren müssen, müssen Sie die Autocommit-Option festlegen.

// 查看autocommit配置值（1或者ON则表示开启）
mysql root@127.0.0.1:(none)> show variables like '%autocommit%';
+---------------+-------+
| Variable_name | Value |
+---------------+-------+
| autocommit | ON |
+---------------+-------+
1 row in set
Time: 0.018s
// 设置autocommit配置值
mysql root@127.0.0.1:(none)> set autocommit = 0;
Query OK, 0 rows affected
Time: 0.000s
mysql root@127.0.0.1:(none)> show variables like '%autocommit%';
+---------------+-------+
| Variable_name | Value |
+---------------+-------+
| autocommit | OFF |
+---------------+-------+
1 row in set
Time: 0.013s

1. Die Tabellenstruktur ist wie folgt

mysql root@127.0.0.1:test> desc user;
+-------+--------------+------+-----+---------+----------------+
| Field | Type | Null | Key | Default | Extra |
+-------+--------------+------+-----+---------+----------------+
| id | int(11) | NO | PRI | <null> | auto_increment |
| name | varchar(255) | YES | | <null> | |
| age | int(2) | YES | | <null> | |
+-------+--------------+------+-----+---------+----------------+
3 rows in set
Time: 0.013s

SQL-Anweisung

CREATE TABLE `test`.`Untitled` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`name` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL,
`age` int(2) NULL DEFAULT NULL,
PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 3 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_general_ci ROW_FORMAT = Dynamic;

2. Transaktionen verwenden

MySQL implementiert Transaktionen

Im folgenden Code führen wir hauptsächlich die folgenden Operationen aus

Transaktion öffnen

b. Daten ändern

c. Fragen Sie ab, ob sich die Daten geändert haben.

e hat sich wieder in den Zustand vor der Änderung geändert

f. Daten ändern

g. Fragen Sie die Daten ab und stellen Sie fest, dass sich die Daten gegenüber der letzten Änderung geändert haben Zustand

i. Versuchen Sie ein Transaktions-Rollback

j. Stellen Sie fest, dass sich die Daten noch im zuletzt geänderten Zustand befinden und das Transaktions-Rollback fehlgeschlagen ist

// 我们先查看表中的数据,id为1的age字段是12
mysql root@127.0.0.1:test> select * from user;
+----+------+-----+
| id | name | age |
+----+------+-----+
| 1 | 张三 | 12 |
| 2 | 李四 | 15 |
+----+------+-----+
2 rows in set
Time: 0.013s
// 开启事务
mysql root@127.0.0.1:test> begin;
Query OK, 0 rows affected
Time: 0.001s
// 将id为1的age字段改为10
mysql root@127.0.0.1:test> update user set age=10 where id=1;
Query OK, 1 row affected
Time: 0.001s
// 再次查询数据时,发现数据改为修改后的值
mysql root@127.0.0.1:test> select * from user;
+----+------+-----+
| id | name | age |
+----+------+-----+
| 1 | 张三 | 10 |
| 2 | 李四 | 15 |
+----+------+-----+
2 rows in set
Time: 0.012s
// 此时我们进行回滚操作
mysql root@127.0.0.1:test> rollback;
Query OK, 0 rows affected
Time: 0.001s
// 再次查询发现数据回到最初状态
mysql root@127.0.0.1:test> select * from user;
+----+------+-----+
| id | name | age |
+----+------+-----+
| 1 | 张三 | 12 |
| 2 | 李四 | 15 |
+----+------+-----+
2 rows in set
Time: 0.019s
// 我们再次对数据进行修改
mysql root@127.0.0.1:test> update user set age=15 where id=1;
Query OK, 1 row affected
Time: 0.001s
// 此时将事务进行提交
mysql root@127.0.0.1:test> commit;
Query OK, 0 rows affected
Time: 0.000s
// 发现此时的数据变为我们最终提交的值
mysql root@127.0.0.1:test> select * from user;
+----+------+-----+
| id | name | age |
+----+------+-----+
| 1 | 张三 | 15 |
| 2 | 李四 | 15 |
+----+------+-----+
2 rows in set
Time: 0.012s
// 我们尝试用刚才回滚的方式进行还原数据
mysql root@127.0.0.1:test> rollback;
Query OK, 0 rows affected
Time: 0.000s
// 发现数据无法回退了,仍然是提交后的数据
mysql root@127.0.0.1:test> select * from user;
+----+------+-----+
| id | name | age |
+----+------+-----+
| 1 | 张三 | 15 |
| 2 | 李四 | 15 |
+----+------+-----+
2 rows in set
Time: 0.017s

Beispielcode für die PHP-Transaktionsimplementierung

<?php
// 连接MySQL
$mysqli = new mysqli(&#39;127.0.0.1&#39;, &#39;root&#39;, &#39;123456&#39;, &#39;test&#39;, 3306);
// 关闭事务自动提交
$mysqli->autocommit(false);
// 1.开启事务
$mysqli->begin_transaction();
// 2.修改数据
$mysqli->query("update user set age=10 where id=1");
// 3.查看数据
$mysqli->query("select * from user");
// 4.事务回滚
$mysqli->rollback();
// 5.查看数据
$mysqli->query("select * from user");
// 7.修改数据
$mysqli->query("update user set age=15 where id=1");
// 8.事务提交
$mysqli->commit();
// 9.事务回滚
$mysqli->rollback();
// 10.查看数据
$mysqli->query("select * from user");

So legen Sie die Isolationsstufe einer Transaktion fest

// 查看当前的事务隔离级别
mysql root@127.0.0.1:test> select @@tx_isolation;
+-----------------+
| @@tx_isolation |
+-----------------+
| REPEATABLE-READ |
+-----------------+
1 row in set
Time: 0.015s
// 设置隔离级别
set session transaction isolation level 隔离级别(上面事务隔离级别中的英文单词);

Das obige ist der detaillierte Inhalt vonDie umfassendste und detaillierteste Erklärung von MySQL-Transaktionen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!