Da es sich um die vollständigste MVCC-Datenbank im gesamten Netzwerk handelt, bin ich für unvollständige Erklärungen verantwortlich.

Verwandte Lernempfehlungen: MySQL-Tutorial

Was ist MVCC

Der vollständige Name ist Multi-Version Concurrency Control, was hauptsächlich Multi-Version-Parallelitätskontrolle ist um die Leistung der Datenbank zu verbessern Parallelitätsleistung. In den folgenden Artikeln geht es ausschließlich um die InnoDB-Engine, da myIsam keine Transaktionen unterstützt. 多版本并发控制，主要是为了提高数据库的并发性能。以下文章都是围绕InnoDB引擎来讲，因为myIsam不支持事务。

同一行数据平时发生读写请求时，会上锁阻塞住。但mvcc用更好的方式去处理读—写请求，做到在发生读—写请求冲突时不用加锁。

这个读是指的快照读，而不是当前读，当前读是一种加锁操作，是悲观锁。

那它到底是怎么做到读—写不用加锁的，快照读和当前读又是什么鬼，跟着你们的贴心老哥，继续往下看。

当前读、快照读都是什么鬼

什么是MySQL InnoDB下的当前读和快照读？

当前读

它读取的数据库记录，都是当前最新的版本，会对当前读取的数据进行加锁，防止其他事务修改数据。是悲观锁的一种操作。

如下操作都是当前读：

• select lock in share mode (共享锁)

• select for update (排他锁)

• update (排他锁)

• insert (排他锁)

• delete (排他锁)

• 串行化事务隔离级别

快照读

快照读的实现是基于多版本并发控制，即MVCC，既然是多版本，那么快照读读到的数据不一定是当前最新的数据，有可能是之前历史版本的数据。

如下操作是快照读：

• 不加锁的select操作（注：事务级别不是串行化）

快照读与mvcc的关系

MVCCC是“维持一个数据的多个版本，使读写操作没有冲突”的一个抽象概念。

这个概念需要具体功能去实现，这个具体实现就是快照读。（具体实现下面讲）

听完贴心老哥的讲解，是不是瞬间茅厕顿开。

数据库并发场景

• 读-读：不存在任何问题，也不需要并发控制

• 读-写：有线程安全问题，可能会造成事务隔离性问题，可能遇到脏读，幻读，不可重复读

• 写-写：有线程安全问题，可能会存在更新丢失问题，比如第一类更新丢失，第二类更新丢失

MVCC解决并发哪些问题？

mvcc用来解决读—写冲突的无锁并发控制，就是为事务分配单向增长的时间戳。为每个数据修改保存一个版本，版本与事务时间戳相关联。

读操作只读取该事务开始前的数据库快照。

解决问题如下：

• 并发读-写时：可以做到读操作不阻塞写操作，同时写操作也不会阻塞读操作。

• 解决脏读、幻读、不可重复读等事务隔离问题，但不能解决上面的写-写 更新丢失问题。

因此有了下面提高并发性能的组合拳：

• MVCC + 悲观锁：MVCC解决读写冲突，悲观锁解决写写冲突

• MVCC + 乐观锁：MVCC解决读写冲突，乐观锁解决写写冲突

MVCC的实现原理

它的实现原理主要是版本链，undo日志 ，Read View 来实现的

版本链

我们数据库中的每行数据，除了我们肉眼看见的数据，还有几个隐藏字段，得开天眼才能看到。分别是db_trx_id、db_roll_pointer、db_row_id

Wenn eine Lese- oder Schreibanforderung für dieselbe Datenzeile auftritt, wird diese gesperrt und blockiert. Mvcc verwendet jedoch eine bessere Methode zur Verarbeitung von Lese-/Schreibanforderungen, sodass keine Sperre erforderlich ist, wenn ein Konflikt mit Lese-/Schreibanforderungen auftritt.

• Dieser Lesevorgang bezieht sich auf den Snapshot-Lesevorgang, nicht auf den aktuellen Lesevorgang. Der aktuelle Lesevorgang ist ein Sperrvorgang, bei dem es sich um eine pessimistische Sperre handelt.
  Wie erreicht man dann das Lesen und Schreiben ohne Sperren? Was zum Teufel sind Snapshot Reading und Current Reading? >, weiterlesen. 🎜

  

  Was zum Teufel sind aktuelle Lesevorgänge und Snapshot-Lesevorgänge? 🎜🎜Was sind aktuelle Lesevorgänge und Snapshots unter MySQL InnoDB? lesen? 🎜

  Aktueller Messwert

  🎜Die gelesenen Datenbankdatensätze sind alle die derzeit neueste Version, die aktuell angezeigt wird Gelesene Daten werden gesperrt, um zu verhindern, dass andere Transaktionen die Daten ändern. Es handelt sich um eine Operation der pessimistischen Sperre. 🎜🎜Die folgenden Vorgänge sind alle aktuellen Lesevorgänge: 🎜🎜🎜🎜Sperre im Freigabemodus auswählen (gemeinsame Sperre)🎜
🎜🎜Für Aktualisierung auswählen (exklusive Sperre)🎜🎜🎜Aktualisierung (exklusive Sperre)🎜 🎜🎜Einfügen (exklusive Sperre)🎜🎜🎜Löschen (exklusive Sperre)🎜🎜🎜Serialisierte Transaktionsisolationsstufe🎜

Snapshot-Lesen

🎜Die Implementierung des Snapshot-Lesens basiert auf der Multi-Version-Parallelitätskontrolle, also MVCC. Da es sich um eine Multiversion handelt, werden die Daten per Snapshot gelesen Der Messwert ist nicht unbedingt der aktuelle. Die neuesten Daten können Daten aus früheren historischen Versionen sein. 🎜🎜Die folgenden Vorgänge sind Snapshot-Lesevorgänge: 🎜🎜🎜Vorgang ohne Sperre auswählen (Hinweis: Transaktionsebene wird nicht serialisiert)

Snapshot-Lesevorgänge und die Beziehung von mvcc

🎜MVCCC ist ein abstraktes Konzept, das „mehrere Versionen von Daten verwaltet, sodass es bei Lese- und Schreibvorgängen nicht zu Konflikten kommt“. 🎜🎜Dieses Konzept erfordert die Implementierung spezifischer Funktionen, und diese spezifische Implementierung ist Snapshot-Lesen. (Die konkrete Implementierung wird weiter unten besprochen) 🎜🎜Nachdem ich mir die Erklärung von dem rücksichtsvollen Bruder angehört hatte, öffnete sich die Toilette plötzlich sofort öffnet? 🎜

Datenbank-Parallelitätsszenario 🎜🎜🎜🎜Lesen-Lesen: Es gibt keine Problem, und es ist keine Parallelitätskontrolle erforderlich🎜🎜🎜Lesen-Schreiben: Es gibt Thread-Sicherheitsprobleme, die zu Problemen bei der Transaktionsisolation führen können und zu Dirty Reads, Phantom Reads und Non führen können -Wiederholbare Lesevorgänge 🎜🎜🎜Schreiben-Schreiben: Es gibt Thread-Sicherheitsprobleme, es kann Probleme mit Aktualisierungsverlusten geben, z. B. die erste Art von Aktualisierungsverlust, die zweite Art von Aktualisierungsverlust🎜

Welche Parallelitätsprobleme löst MVCC? 🎜🎜Die von mvcc zur Lösung von Lese-/Schreibkonflikten verwendete sperrenfreie Parallelitätskontrolle besteht darin, Transaktionen Zeitstempel zuzuweisen, die in eine Richtung wachsen. Für jede Datenänderung wird eine Version gespeichert, und die Version ist mit dem Transaktionszeitstempel verknüpft. 🎜🎜Der Lesevorgang liest nur den Datenbank-Snapshot, bevor die Transaktion startet. 🎜🎜Die Lösung des Problems lautet wie folgt:🎜🎜🎜🎜Gleichzeitiges Lesen/Schreiben: Der Lesevorgang blockiert den Schreibvorgang nicht und der Schreibvorgang nicht Blockieren Sie den Lesevorgang. 🎜🎜🎜Lösen Sie Transaktionsisolationsprobleme wie Dirty Reads, Phantom Reads, nicht wiederholbare Lesevorgänge, können die oben genannten Probleme jedoch nicht lösen Write-Write-Update verloren-Problem. 🎜🎜Es gibt also den folgenden Kombinationsschlag, um die Parallelitätsleistung zu verbessern:🎜🎜🎜🎜MVCC + pessimistische Sperre : MVCC löst Lese-Schreib-Konflikte, pessimistische Sperre löst Schreib-Schreib-Konflikte🎜🎜🎜MVCC + Optimistische Sperre: MVCC löst Lese-Schreib-Konflikte und optimistische Sperre löst Schreib-Schreib-Konflikte 🎜

Das Implementierungsprinzip von MVCC🎜🎜Das Implementierungsprinzip besteht hauptsächlich aus Versionskette, Rückgängig-Protokoll code>, <code> Leseansicht ist implementiert 🎜

Versionskette

🎜Jede Datenzeile in unserer Datenbank, zusätzlich zu den Daten, die wir sehen können Mit bloßem Auge gibt es mehrere Versteckte Felder, Sie müssen Sky Eye öffnen, um es zu sehen. Dies sind db_trx_id, db_roll_pointer und db_row_id. 🎜🎜🎜🎜db_trx_id🎜

6 Byte, letzte Änderung (Änderung/Einfügung) Transaktions-ID: Datensatz Erstellung dieses Datensatzes/Letzte Änderung der Transaktion davon Datensatz-ID. 事务ID：记录创建这条记录/最后一次修改该记录的事务ID。

db_roll_pointer（版本链关键）

7byte，回滚指针，指向这条记录的上一个版本（存储于rollback segment里）

db_row_id

6byte，隐含的自增ID（隐藏主键），如果数据表没有主键，InnoDB会自动以db_row_id产生一个聚簇索引。

实际还有一个删除flag隐藏字段, 记录被更新或删除并不代表真的删除，而是删除flag变了

如上图，db_row_id是数据库默认为该行记录生成的唯一隐式主键，db_trx_id是当前操作该记录的事务ID，而db_roll_pointer是一个回滚指针，用于配合undo日志，指向上一个旧版本。

每次对数据库记录进行改动，都会记录一条undo日志，每条undo日志也都有一个roll_pointer属性（INSERT操作对应的undo日志没有该属性，因为该记录并没有更早的版本），可以将这些undo日志都连起来，串成一个链表，所以现在的情况就像下图一样：

对该记录每次更新后，都会将旧值放到一条undo日志中，就算是该记录的一个旧版本，随着更新次数的增多，所有的版本都会被roll_pointer属性连接成一个链表，我们把这个链表称之为版本链，版本链的头节点就是当前记录最新的值。另外，每个版本中还包含生成该版本时对应的事务id，这个信息很重要，在根据ReadView判断版本可见性的时候会用到。

undo日志

Undo log 主要用于记录数据被修改之前的日志，在表信息修改之前先会把数据拷贝到undo log里。

当事务进行回滚时可以通过undo log 里的日志进行数据还原。

Undo log 的用途

• 保证事务进行rollback时的原子性和一致性，当事务进行回滚的时候可以用undo log的数据进行恢复。

• 用于MVCC快照读的数据，在MVCC多版本控制中，通过读取undo log的历史版本数据可以实现不同事务版本号都拥有自己独立的快照数据版本。

undo log主要分为两种：

• insert undo log

  代表事务在insert新记录时产生的undo log , 只在事务回滚时需要，并且在事务提交后可以被立即丢弃

• update undo log（主要）

  事务在进行update或delete时产生的undo log ; 不仅在事务回滚时需要，在快照读时也需要；

  所以不能随便删除，只有在快速读或事务回滚不涉及该日志时，对应的日志才会被purge线程统一清除

Read View(读视图)

事务进行快照读操作的时候生产的读视图(Read View)，在该事务执行的快照读的那一刻，会生成数据库系统当前的一个快照。

记录并维护系统当前活跃事务的ID(没有commit，当每个事务开启时，都会被分配一个ID, 这个ID是递增的，所以越新的事务，ID值越大)，是系统中当前不应该被本事务看到的其他事务id列表。

Read View主要是用来做可见性判断的, 即当我们某个事务执行快照读的时候，对该记录创建一个Read View读视图，把它比作条件用来判断当前事务能够看到哪个版本的数据，既可能是当前最新的数据，也有可能是该行记录的undo log里面的某个版本的数据。

Read View几个属性

• trx_ids: 当前系统活跃(未提交)事务版本号集合。

• low_limit_id: 创建当前read view 时“当前系统最大事务版本号

• db_roll_pointer (Versionskettenschlüssel) 🎜🎜7 Byte, Rollback-Zeiger, der auf die vorherige Version von diesem Datensatzzeigt > code> (im Rollback-Segment gespeichert) 🎜
• 🎜db_row_id🎜🎜6byte, implizite Auto-Inkrement-ID (versteckter Primärschlüssel), wenn die Datentabelle dies nicht tut Wenn Sie einen Primärschlüssel haben, generiert InnoDB automatisch einen <code>Clustered-Index basierend auf db_row_id. 🎜
• 🎜Es gibt tatsächlich ein verstecktes Feld löschen. Nur weil ein Datensatz aktualisiert oder gelöscht ist, heißt das nicht es ist tatsächlich gelöscht. , aber delete flag wurde geändert🎜

🎜Wie oben gezeigt, db_row_id ist der eindeutige implizite Primärschlüssel, der von der Datenbank standardmäßig für diese Datensatzzeile generiert wird, db_trx_id ist die Transaktions-ID von der aktuelle Vorgang für den Datensatz, und db_roll_pointer ist ein Rollback-Zeiger, der mit Rückgängig-Protokoll verwendet wird und auf die vorherige alte Version. 🎜🎜Jedes Mal, wenn ein Datenbankeintrag geändert wird, wird ein <code>Rückgängig-Protokoll aufgezeichnet. Jedes Rückgängig-Protokoll verfügt auch über ein roll_pointer-Attribut (das dem INSERT-Vorgang entsprechende Rückgängig-Protokoll nicht). Wenn Sie dieses Attribut haben, da der Datensatz keine frühere Version hat), können diese Rückgängig-Protokolle verbunden und in einer verknüpften Liste aufgereiht werden, so dass die aktuelle Situation wie auf dem Bild aussieht unten: 🎜

🎜Jedes Mal, wenn der Datensatz aktualisiert wird, wird der alte Wert in ein Rückgängig-Protokoll eingefügt, auch wenn es sich um eine alte Version des Datensatzes handelt Wenn die Anzahl der Aktualisierungen zunimmt, werden alle Versionen durch das Attribut roll_pointer zu einer verknüpften Liste verbunden. Wir nennen diese verknüpfte Liste Versionskette und Der Kopf der Versionskette Der Knoten ist der neueste Wert des aktuellen Datensatzes. Darüber hinaus enthält jede Version auch die entsprechende Transaktions-ID zum Zeitpunkt der Versionsgenerierung. Diese Informationen sind sehr wichtig und werden bei der Beurteilung der Sichtbarkeit der Version basierend auf ReadView verwendet. 🎜

Rückgängig-Protokoll

🎜Das Rückgängig-Protokoll wird hauptsächlich verwendet, um das Protokoll zu aufzeichnen, bevor die Daten geändert werden Die Tabelleninformationen Vor der Änderung werden die Daten in das Rückgängig-Protokoll kopiert. 🎜🎜Wenn Transaktion zurückgesetzt wird, können Sie die Datenwiederherstellung über das Protokoll zum Rückgängigmachen der Anmeldung durchführen. 🎜🎜Zweck des Rückgängig-Protokolls🎜

• 🎜Stellen Sie Atomizität und Konsistenztransaction einen Rollback /code> durchführt Wenn die Transaktion zurückgesetzt wird, können die Rückgängig-Protokolldaten zur Wiederherstellung verwendet werden. 🎜
• 🎜Die Daten, die für das MVCC-Snapshot-Lesen in der MVCC-Mehrversionskontrolle verwendet werden, indem die historischen Versionsdaten des <code>Rückgängig-Protokolls gelesen werden Es kann erkannt werden, dass verschiedene Transaktionsversionsnummern ihre eigenen unabhängigen Snapshot-Datenversionen haben. 🎜

🎜Das Rückgängig-Protokoll ist hauptsächlich in zwei Typen unterteilt: 🎜

• 🎜Rückgängig-Protokoll einfügen🎜🎜 stellt das Rückgängig-Protokoll dar, das generiert wird, wenn eine Transaktion eine neue einfügt Datensatz, nur erforderlich, wenn die Transaktion zurückgesetzt wird, und kann sofort nach dem Festschreiben der Transaktion verworfen werden🎜
• 🎜Rückgängig-Protokoll aktualisieren (Haupt)🎜🎜Das Rückgängig-Protokoll, das generiert wird, wenn die Transaktion aktualisiert oder gelöscht wird; Nicht nur, wenn die Transaktion zurückgesetzt wird. Es wird auch beim Lesen von Snapshots benötigt. 🎜🎜Es kann also nicht beiläufig gelöscht werden. Nur wenn das Protokoll nicht am schnellen Lesen oder Transaktions-Rollback beteiligt ist einheitlich durch den Löschthread gelöscht werden🎜

Leseansicht

🎜Die Leseansicht, die bei der Ausführung der Transaktion erstellt wird Mit der Operation Snapshot lesen (Ansicht lesen) wird in dem Moment, in dem der von der Transaktion ausgeführte Snapshot gelesen wird, ein aktueller Snapshot des Datenbanksystems generiert. 🎜🎜Erfassen und pflegen Sie die aktuelle ID der aktiven Transaktionen des Systems (ohne Commit wird jeder Transaktion beim Start eine ID zugewiesen. Diese ID nimmt zu, d. h. je neuer die Transaktion, desto höher die ID-Wert. Groß) ist eine Liste anderer Transaktions-IDs im System, die derzeit von dieser Transaktion nicht gesehen werden sollten. 🎜🎜Die Leseansicht wird hauptsächlich zur Beurteilung der Sichtbarkeit verwendet. Das heißt, wenn wir eine bestimmte Transaktion Snapshot-Lesen durchführen, erstellen wir eine Leseansicht für den Datensatz und vergleichen Sie es mit einer Bedingung, um zu bestimmen, welche Datenversion die aktuelle Transaktion sehen kann, wobei es sich dabei möglicherweise um die aktuellen neuesten Daten handeln kann eine bestimmte Version im Rückgängig-Protokoll, das in dieser Zeile aufgezeichnet wird. 🎜🎜Mehrere Eigenschaften der Leseansicht🎜

• 🎜trx_ids: Eine Sammlung aktiver (uncommitted) Transaktionsversionsnummern in der aktuelles System. 🎜
• 🎜low_limit_id: „Aktuelles System maximale Transaktionsversionsnummer+1“ beim Erstellen der aktuellen Leseansicht. 🎜

• up_limit_id: „Das System befindet sich in aktiver Transaktion Mindestversionsnummer“ beim Erstellen der aktuellen Leseansicht up_limit_id: 创建当前read view 时“系统正处于活跃事务最小版本号”

• creator_trx_id: 创建当前read view的事务版本号；

Read View可见性判断条件

• db_trx_id < up_limit_id || db_trx_id == creator_trx_id（显示）

  如果数据事务ID小于read view中的最小活跃事务ID，则可以肯定该数据是在当前事务启之前就已经存在了的,所以可以显示。

  或者数据的事务ID等于creator_trx_id ，那么说明这个数据就是当前事务自己生成的，自己生成的数据自己当然能看见，所以这种情况下此数据也是可以显示的。

• db_trx_id >= low_limit_id（不显示）

  如果数据事务ID大于read view 中的当前系统的最大事务ID，则说明该数据是在当前read view 创建之后才产生的，所以数据不显示。如果小于则进入下一个判断

• db_trx_id是否在活跃事务（trx_ids）中

  • 不存在：则说明read view产生的时候事务已经commit了，这种情况数据则可以显示。

  • 已存在：则代表我Read View生成时刻，你这个事务还在活跃，还没有Commit，你修改的数据，我当前事务也是看不见的。

MVCC和事务隔离级别

上面所讲的Read View用于支持RC（Read Committed，读提交）和RR（Repeatable Read，可重复读）隔离级别的实现。

RR、RC生成时机

• RC隔离级别下，是每个快照读都会生成并获取最新的Read View；

• 而在RR隔离级别下，则是同一个事务中的第一个快照读才会创建Read View, 之后的快照读获取的都是同一个Read View，之后的查询就不会重复生成了，所以一个事务的查询结果每次都是一样的。

解决幻读问题

• 快照读：通过MVCC来进行控制的，不用加锁。按照MVCC中规定的“语法”进行增删改查等操作，以避免幻读。

• 当前读：通过next-key锁（行锁+gap锁）来解决问题的。

RC、RR级别下的InnoDB快照读区别

• 在RR级别下的某个事务的对某条记录的第一次快照读会创建一个快照及Read View， 将当前系统活跃的其他事务记录起来，此后在调用快照读的时候，还是使用的是同一个Read View，所以只要当前事务在其他事务提交更新之前使用过快照读，那么之后的快照读使用的都是同一个Read View，所以对之后的修改不可见；

• 即RR级别下，快照读生成Read View时，Read View会记录此时所有其他活动事务的快照，这些事务的修改对于当前事务都是不可见的。而早于Read View创建的事务所做的修改均是可见

• 而在RC级别下的，事务中，每次快照读都会新生成一个快照和Read View, 这就是我们在RC级别下的事务中可以看到别的事务提交的更新的原因

总结

从以上的描述中我们可以看出来，所谓的MVCC指的就是在使用READ COMMITTD、REPEATABLE READ这两种隔离级别的事务在执行普通的SEELCT操作时访问记录的版本链的过程，这样子可以使不同事务的读-写、写-读操作并发执行，从而提升系统性能

creator_trx_id: Wird erstellt der aktuelle Lesevorgang. Die Transaktionsversionsnummer der Ansicht. Figure>

db_trx_id < up_limit_id || db_trx_id == creator_trx_id (Anzeige)

Wenn die Datentransaktions-ID kleiner als die minimale aktive Transaktions-ID in der Leseansicht ist, können Sie sicher sein, dass die Daten bereits vor der aktuellen Transaktion <code>existieren gestartet, damit es Anzeige kann.

🎜 Oder die Transaktions-ID der Daten ist gleich creator_trx_id, dann bedeutet das natürlich, dass die Daten durch die aktuelle Transaktion generiert werden Die von Ihnen generierten Daten sind für Sie selbst einsehbar, sodass diese Daten in diesem Fall auch angezeigt werden können. 🎜🎜🎜🎜db_trx_id >= low_limit_id (nicht angezeigt) 🎜🎜Wenn die Datentransaktions-ID größer als die maximale Transaktions-ID des aktuellen Systems beim Lesen ist Ansicht bedeutet, dass die Daten generiert werden , nachdem die aktuelle Leseansicht erstellt wurde , sodass die Daten <code>nicht angezeigt werden. Wenn es kleiner ist als, fahren Sie mit der nächsten Beurteilung fort 🎜🎜🎜🎜db_trx_id Ob es sich um eine aktive Transaktion (trx_ids) handelt 🎜

🎜🎜nicht vorhanden: Dies bedeutet, dass die Transaktion festgeschrieben wurde, als die Leseansicht generiert wurde. In diesem Fall können die Daten angezeigt werden. 🎜🎜🎜🎜Existiert: Dies bedeutet, dass Ihre Transaktion beim Generieren meiner Leseansicht noch aktiv ist und noch nicht festgeschrieben wurde. Die von Ihnen geänderten Daten sind auch für meine aktuelle Transaktion unsichtbar. 🎜🎜

🎜

MVCC und Transaktionsisolationsstufe

🎜Oben Die erwähnte Read View wird zur Unterstützung von RC (Read Committed, Read Submission) und RR (Repeatable Read, wiederholbares Lesen) Implementierung der Isolationsstufe. 🎜

RR- und RC-Generierungszeitpunkt

🎜🎜RCUnter der Isolationsstufe wird jeder Snapshot gelesen Wird generieren und erhalten die neueste Leseansicht 🎜🎜🎜🎜 Und unter der Isolationsstufe RR handelt es sich um die gleiche Transaktion Read View wird erst nach dem ersten Snapshot-Lesevorgang in erstellt, und nach Snapshot-Lesevorgängen wird dasselbe mit einem erhalten Wenn Sie die Ansicht lesen, werden nachfolgende Abfragen nicht wiederholt generiert, sodass die Abfrageergebnisse einer Transaktion jedes Mal gleich sind. 🎜🎜

Lösen des Phantomleseproblems

🎜🎜Snapshot-Lesen: Wird über MVCC gesteuert, muss nicht hinzugefügt werden Sperren. Führen Sie Vorgänge wie Hinzufügungen, Löschungen, Änderungen und Suchen gemäß der in MVCC angegebenen „Grammatik“ durch, um Phantomlesen zu vermeiden. 🎜🎜🎜🎜Aktuell gelesen: Das Problem wird durch die Next-Key-Sperre (Zeilensperre + Lückensperre) gelöst. 🎜🎜

Der Unterschied zwischen dem Lesen von InnoDB-Snapshots auf RC- und RR-Ebene

🎜🎜Ein bestimmter Datensatz einer bestimmten Transaktion auf RR-Ebene Beim ersten Snapshot-Lesen werden ein Snapshot und eine Leseansicht erstellt, um andere aktive Transaktionen im aktuellen System aufzuzeichnen. Danach wird beim Aufrufen des Snapshot-Lesens weiterhin dieselbe Leseansicht verwendet, solange die aktuelle Transaktion Aktualisierungen in anderen Transaktionen festschreibt Wenn Sie zuvor Snapshot-Lesevorgänge verwendet haben, verwenden nachfolgende Snapshot-Lesevorgänge dieselbe Leseansicht, sodass nachfolgende Änderungen nicht sichtbar sind View zeichnet dieses Mal eine Momentaufnahme aller anderen aktiven Transaktionen auf, deren Änderungen für die aktuelle Transaktion unsichtbar sind. Die Änderungen, die durch Transaktionen vorgenommen wurden, die vor der Leseansicht erstellt wurden, sind alle sichtbar. Auf der RC-Ebene wird bei jedem Snapshot-Lesen ein neuer Snapshot und eine neue Leseansicht generiert Sie können die Gründe für Aktualisierungen sehen, die von anderen Transaktionen in der Transaktion übermittelt wurden MVCC Es bezieht sich auf den , der aufgezeichnet wird, wenn die beiden Isolationsebenen-Transaktionen <code>READ COMMITTD und REPEATABLE READ zum Ausführen gewöhnlicher SEELCT-Operationen > verwendet werden Der Prozess der Versionskette, auf diese Weise können die Vorgänge Lesen/Schreiben und Schreiben/Lesen verschiedener Transaktionen gleichzeitigausgeführt werden >, also Systemleistung verbessern. 🎜🎜🎜Wenn Sie mehr über das Erlernen des Programmierens erfahren möchten, achten Sie bitte auf die Spalte „PHP-Schulung“! 🎜🎜🎜

Das obige ist der detaillierte Inhalt vonDa es sich um die vollständigste MVCC-Datenbank im gesamten Netzwerk handelt, bin ich für unvollständige Erklärungen verantwortlich.. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!