Detaillierte Analyse des MySQL-Sperrmechanismus

Dieser Artikel vermittelt Ihnen relevantes Wissen über MySQL, in dem hauptsächlich die verschiedenen Sperrmechanismen in MySQL vorgestellt werden. Sperren werden von der Datenbank verwendet, um die Konsistenz von Daten sicherzustellen und verschiedene gemeinsam genutzte Ressourcen zu verwenden Ordentlich bei Ihrem Besuch. Ich hoffe, es wird für alle hilfreich sein.

Empfohlenes Lernen: MySQL-Tutorial

MySQL-Sperre:

Wie stellt man die Genauigkeit von Daten beim Multithreading sicher? Das ist richtig, durch Synchronisierung. Die Synchronisierung entspricht dem Sperren. Welche Vorteile bietet das Hinzufügen eines Schlosses? Wenn ein Thread tatsächlich Daten manipuliert, können andere Threads nur warten. Wenn die Ausführung eines Threads abgeschlossen ist, wird die Sperre aufgehoben. Nur andere Threads können Operationen ausführen!

Dann ist die Funktion von Sperren in unserer MySQL-Datenbank ähnlich. Bei der Isolierung der Transaktionsverarbeitung können Probleme wie schmutzige Lesevorgänge, nicht wiederholbare Lesevorgänge und Phantom-Lesevorgänge auftreten.

In einer Datenbank sind Daten eine Ressource, die von vielen Benutzern gemeinsam genutzt wird und auf die viele Benutzer zugreifen. Aufgrund der Merkmale ihrer eigenen Architektur muss MySQL die Konsistenz und Effektivität des gleichzeitigen Zugriffs auf Daten sicherstellen Motoren sind alle mit Verriegelungsmechanismen für bestimmte Szenarien ausgestattet, daher führen die Unterschiede bei den Motoren zu sehr unterschiedlichen Verriegelungsmechanismen.

Sperrmechanismus:

Um die Konsistenz der Daten sicherzustellen, verwendet die Datenbank eine Regel, die unter Verwendung verschiedener gemeinsam genutzter Ressourcen entwickelt wurde, um bei gleichzeitigem Zugriff ordnungsgemäß zu funktionieren.

Zum Beispiel: Beim Kauf eines Produkts auf einer E-Commerce-Website gibt es nur ein Produkt in der Produktliste, und zu diesem Zeitpunkt kaufen es zwei Personen gleichzeitig. Daher ist es von entscheidender Bedeutung, wer es kaufen kann.

Transaktionen werden hier verwendet, um eine Reihe von Vorgängen auszuführen:

Zuerst die Artikeldaten aus der Produkttabelle abrufen

Dann die Bestellung eingeben

Nach der Zahlung die Zahlungstabelleninformationen eingeben

Aktualisieren Sie die Menge der Artikel in Die Produkttabelle

Im obigen Prozess können Sperren verwendet werden, um Produktmengendateninformationen zu schützen und eine Isolierung zu erreichen, d. h. nur der erste Benutzer darf den gesamten Kaufvorgang abschließen, während andere Benutzer nur warten können, wodurch das Problem gelöst wird Konfliktproblem in der Parallelität.

Klassifizierung von Sperren:

Klassifizierung nach Vorgang:

Gemeinsame Sperre: auch Lesesperre genannt. Für dieselben Daten können mehrere Transaktionslesevorgänge gleichzeitig gesperrt werden, ohne sich gegenseitig zu beeinflussen, die Datensätze können jedoch nicht geändert werden.

Exklusive Sperre: auch Schreibsperre genannt. Bevor der aktuelle Vorgang abgeschlossen ist, wird das Lesen und Schreiben anderer Vorgänge blockiert. Klassifizierung nach Granularität:

Sperre auf Tabellenebene: Während des Vorgangs wird die gesamte Tabelle gesperrt. Der Overhead ist gering und die Sperrung erfolgt schnell; die Sperrkraft ist hoch, die Wahrscheinlichkeit eines Sperrenkonflikts ist hoch und die Parallelität ist am geringsten. Bevorzugen Sie die MyISAM-Speicher-Engine!

Sperre auf Zeilenebene: Während des Betriebs wird die aktuelle Betriebszeile gesperrt. Der Overhead ist groß und das Sperren ist langsam; die Sperrgranularität ist gering, die Wahrscheinlichkeit von Sperrenkonflikten ist gering und die Parallelität ist hoch. Bevorzugen Sie die InnoDB-Speicher-Engine!

Sperre auf Seitenebene: Die Sperrgranularität, die Konfliktwahrscheinlichkeit und die Sperrkosten liegen zwischen Tabellensperren und Zeilensperren, und die Parallelitätsleistung ist durchschnittlich.

Nach Verwendung klassifiziert:

Pessimistische Sperre: Jedes Mal, wenn Sie die Daten abfragen, denken Sie, dass andere sie ändern werden. Das ist sehr pessimistisch, also sperren Sie sie beim Abfragen.

Optimistische Sperre: Jedes Mal, wenn Sie die Daten abfragen, denken Sie, dass andere sie nicht ändern werden. Sie sind sehr optimistisch, aber beim Aktualisieren werden Sie beurteilen, ob andere die Daten in diesem Zeitraum aktualisiert haben Motoren

Freigabesperre:

Wenn ein Schlüssel vorhanden ist, wird InnoDB standardmäßig auf eine Zeilensperre aktualisiert. Mehrere Fenster können Daten in verschiedenen Zeilen ändern. Wenn Sie auf die Übermittlung des ersten gesperrten Commits warten, können Sie verschiedene Zeilen direkt ändern. Wenn Sie jedoch die andere abfragen möchten, müssen Sie dies tun um auf die später geänderten Commits zu warten. Die Sperre verschwindet nach der Übermittlung

Gemeinsame Sperre:

SELECT语句 LOCK IN SHARE MODE;

Fenster 1:

- 窗口1
/*
    共享锁：数据可以被多个事务查询，但是不能修改
*/
-- 开启事务
START TRANSACTION;
-- 查询id为1的数据记录。加入共享锁
SELECT * FROM student WHERE id=1 LOCK IN SHARE MODE;
-- 查询分数为99分的数据记录。加入共享锁
SELECT * FROM student WHERE score=99 LOCK IN SHARE MODE;
-- 提交事务
COMMIT;

Fenster 2:

-- 窗口2
-- 开启事务
START TRANSACTION;
-- 查询id为1的数据记录(普通查询，可以查询)
SELECT * FROM student WHERE id=1;
-- 查询id为1的数据记录，并加入共享锁(可以查询。共享锁和共享锁兼容)
SELECT * FROM student WHERE id=1 LOCK IN SHARE MODE;
-- 修改id为1的姓名为张三三(不能修改，会出现锁的情况。只有窗口1提交事务后，才能修改成功)
UPDATE student SET NAME='张三三' WHERE id = 1;
-- 修改id为2的姓名为李四四(修改成功，InnoDB引擎默认是行锁)
UPDATE student SET NAME='李四四' WHERE id = 2;
-- 修改id为3的姓名为王五五(修改失败，InnoDB引擎如果不采用带索引的列加锁。则会提升为表锁)
UPDATE student SET NAME='王五五' WHERE id = 3;
-- 提交事务
COMMIT;

Exklusive Sperre:

Wenn die exklusive Sperre ausgeführt wird, können normale Abfragen anderer Transaktionen durchgeführt werden, jedoch keine Sperrvorgänge sind erlaubt.

-- 标准语法
SELECT语句 FOR UPDATE;

Fenster 1:

-- 窗口1
/*
    排他锁：加锁的数据，不能被其他事务加锁查询或修改
*/
-- 开启事务
START TRANSACTION;
-- 查询id为1的数据记录，并加入排他锁
SELECT * FROM student WHERE id=1 FOR UPDATE;
-- 提交事务
COMMIT;

MyISAM-Sperre:

MyISAM-Lesesperre:

myisam ist eine Sperre für die gesamte Tabelle, wenn sie nicht entsperrt ist Transaktionen können überprüft werden, jedoch nicht. Alle anderen Vorgänge, einschließlich der eigenen Transaktion, können nicht ausgeführt werden kann betrieben werden.

Daten müssen während der gesamten Datenverarbeitung gesperrt werden. Pessimistisches Sperren basiert im Allgemeinen auf dem Sperrmechanismus, der von relationalen Datenbanken bereitgestellt wird.

Zeilensperren und Tabellensperren sind pessimistische Sperren, unabhängig davon, ob es sich um Lese-/Schreibsperren handelt.

Optimistische Sperre:

就是很乐观，每次自己操作数据的时候认为没有人会来修改它，所以不去加锁。

但是在更新的时候会去判断在此期间数据有没有被修改。

需要用户自己去实现，不会发生并发抢占资源，只有在提交操作的时候检查是否违反数据完整性。

乐观锁的简单实现方式：

实现思想：加标记去比较，一样则执行，不同则不执行

方式一：版本号

给数据表中添加一个version列，每次更新后都将这个列的值加1。

读取数据时，将版本号读取出来，在执行更新的时候，比较版本号。

如果相同则执行更新，如果不相同，说明此条数据已经发生了变化。

用户自行根据这个通知来决定怎么处理，比如重新开始一遍，或者放弃本次更新。

-- 创建city表
CREATE TABLE city(
    id INT PRIMARY KEY AUTO_INCREMENT,  -- 城市id
    NAME VARCHAR(20),                   -- 城市名称
    VERSION INT                         -- 版本号
);
-- 添加数据
INSERT INTO city VALUES (NULL,'北京',1),(NULL,'上海',1),(NULL,'广州',1),(NULL,'深圳',1);
-- 修改北京为北京市
-- 1.查询北京的version
SELECT VERSION FROM city WHERE NAME='北京';
-- 2.修改北京为北京市，版本号+1。并对比版本号
UPDATE city SET NAME='北京市',VERSION=VERSION+1 WHERE NAME='北京' AND VERSION=1;

方式二：时间戳

和版本号方式基本一样，给数据表中添加一个列，名称无所谓，数据类型需要是timestamp

每次更新后都将最新时间插入到此列。

读取数据时，将时间读取出来，在执行更新的时候，比较时间。

如果相同则执行更新，如果不相同，说明此条数据已经发生了变化。

悲观锁和乐观锁使用前提：

对于读的操作远多于写的操作的时候，这时候一个更新操作加锁会阻塞所有的读取操作，降低了吞吐量。最后还要释放锁，锁是需要一些开销的，这时候可以选择乐观锁。

如果是读写比例差距不是非常大或者系统没有响应不及时，吞吐量瓶颈的问题，那就不要去使用乐观锁，它增加了复杂度，也带来了业务额外的风险。这时候可以选择悲观锁。

推荐学习：mysql学习教程

Das obige ist der detaillierte Inhalt vonDetaillierte Analyse des MySQL-Sperrmechanismus. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!