In diesem Dokument wird beschrieben, wie Sie mit den integrierten Tabellen für Spanner-Sperrstatistiken die Zeilenschlüssel und Tabellenspalten identifizieren, die in einem bestimmten Zeitraum Transaktionssperrkonflikte in Ihrer Datenbank verursacht haben. Sie können Statistiken aus diesen SPANNER_SYS.LOCK_STATS*-Tabellen mithilfe von SQL-Anweisungen abrufen.
Bei Transaktionen, die die optimistische Nebenläufigkeitserkennung verwenden, werden beim Ausführen von Lesevorgängen und Abfragen keine Sperren erworben. Stattdessen werden Sperren zum Zeitpunkt des Commits erworben. Die Sperrstatistiken für diese Transaktionen enthalten also nur Konflikte, die während des Commits auftreten.
Zugriffssperrstatistiken
Spanner stellt die Sperrstatistiken im Schema SPANNER_SYS bereit.
Sie können auf folgende Weise auf SPANNER_SYS-Daten zugreifen:
Die Spanner Studio-Seite einer Datenbank in der Google Cloud Console
Das Dashboard Statistiken zu Sperren.
Die Methode
executeSqloderexecuteStreamingSql.Die folgenden von Spanner bereitgestellten Methoden für einzelne Lesevorgänge unterstützen
SPANNER_SYSnicht:- Starken Lesevorgang aus einer einzelnen Zeile oder mehreren Zeilen in einer Tabelle durchführen
- Lesevorgang veralteter Daten aus einer oder mehreren Zeilen in einer Tabelle ausführen.
- Aus einer einzelnen Zeile oder mehreren Zeilen in einem sekundären Index lesen
Statistiken nach Zeilenschlüssel sperren
In den folgenden Tabellen wird der Zeilenschlüssel mit der höchsten Wartezeit nachverfolgt:
SPANNER_SYS.LOCK_STATS_TOP_MINUTE: Zeilenschlüssel mit den höchsten Wartezeiten für Sperren in 1-Minuten-Intervallen.SPANNER_SYS.LOCK_STATS_TOP_10MINUTE: Zeilenschlüssel mit der höchsten Sperrwartezeit in 10-Minuten-Intervallen.SPANNER_SYS.LOCK_STATS_TOP_HOUR: Zeilenschlüssel mit der Sperrwartezeit in 1-Stunden-Intervallen.
Diese Tabellen haben folgende Attribute:
Jede Tabelle enthält Daten für nicht überlappende Zeitintervalle der Länge, die im Tabellennamen angegeben ist.
Die Intervalle basieren auf der Uhrzeit. 1-Minuten-Intervalle enden zur Minute, 10-Minuten-Intervalle enden alle 10 Minuten ab der vollen Stunde und 1-Stunden-Intervalle enden zur vollen Stunde. Nach jedem Intervall erfasst Spanner Daten von allen Servern und stellt sie kurz darauf in den SPANNER_SYS-Tabellen zur Verfügung.
Beispielsweise sind die neuesten, für SQL-Abfragen verfügbaren Intervalle um 11:59:30 Uhr:
- 1 Minute: 11:58:00–11:58:59 Uhr
- 10 Minuten: 11:40:00–11:49:59 Uhr
- 1 Stunde: 10:00:00–10:59:59 Uhr
Spanner gruppiert die Statistiken nach dem Startzeilenschlüsselbereich.
Jede Zeile enthält Statistiken zur gesamten Sperrwartezeit eines bestimmten Startzeilenschlüsselbereichs, für den Spanner im angegebenen Intervall Statistiken erfasst.
Wenn Spanner keine Informationen zu jedem Zeilenschlüsselbereich für Sperrwartezeiten während des Intervalls speichern kann, priorisiert das System den Zeilenschlüsselbereich mit der höchsten Sperrwartezeit während des angegebenen Intervalls.
Alle Spalten in den Tabellen können Nullwerte enthalten.
Tabellenschema
| Spaltenname | Typ | Beschreibung |
|---|---|---|
INTERVAL_END |
TIMESTAMP |
Ende des Zeitintervalls, in dem die enthaltenen Sperrkonflikte aufgetreten sind. |
ROW_RANGE_START_KEY |
BYTES(MAX) |
Der Zeilenschlüssel, in dem der Sperrkonflikt aufgetreten ist. Wenn der Konflikt einen Bereich von Zeilen beinhaltet, stellt dieser Wert den Startschlüssel dieses Bereichs dar. Ein Pluszeichen, +, bezeichnet einen Bereich.
Weitere Informationen finden Sie unter Was ist ein Startschlüssel für einen Zeilenbereich?.
|
LOCK_WAIT_SECONDS |
FLOAT64 |
Die kumulative Wartezeit der Sperre von Sperrkonflikten, die für alle Spalten im Zeilenschlüsselbereich aufgezeichnet wurden, in Sekunden. |
SAMPLE_LOCK_REQUESTS |
ARRAY<STRUCT<
|
Jeder Eintrag in diesem Array entspricht einer Beispiel-Sperranfrage, die zum Sperrkonflikt beigetragen hat, indem sie entweder auf eine Sperre gewartet oder andere Transaktionen daran gehindert hat, die Sperre für den angegebenen Zeilenschlüsselbereich zu übernehmen. Die maximale Anzahl von Stichproben in diesem Array beträgt 20.
Jedes Beispiel enthält die folgenden drei Felder:
|
SAMPLE_LOCK_REQUESTS_JSON_STRING |
STRING |
Eine JSON-kompatible Stringdarstellung der Spalte SAMPLE_LOCK_REQUESTS. Der JSON-String ist ein JSON-Objekt mit derselben Struktur wie das STRUCT, das in der Spalte SAMPLE_LOCK_REQUESTS definiert ist.
Diese Spalte wird in Datenbanken im GoogleSQL- und PostgreSQL-Dialekt unterstützt. |
LOCK_WAIT_DISTRIBUTION |
ARRAY<STRUCT> |
Ein Histogramm der einzelnen Wartezeiten bei Sperren für Sperrkonflikte, die im Zeilenschlüsselbereich aufgezeichnet wurden. Im Gegensatz zu den anderen Latenzspalten in diesen Tabellen werden die Werte in dieser Spalte in Mikrosekunden angegeben. Teilen Sie sie durch 1.000.000, um sie in Sekunden umzuwandeln.
Das Array enthält ein einzelnes Element und hat den folgenden Typ:
Weitere Informationen zu den Werten finden Sie unter Verteilung und Exponentiell. Verwenden Sie die Funktion |
LOCK_WAIT_DISTRIBUTION_JSON_STRING |
STRING |
Eine JSON-kompatible Stringdarstellung der Spalte Diese Spalte wird in Datenbanken im GoogleSQL- und PostgreSQL-Dialekt unterstützt. |
Sperrmodi
Spanner-Vorgänge rufen Sperren ab, wenn die Vorgänge Teil einer Lese-/Schreibtransaktion sind. Bei schreibgeschützten Transaktionen werden keine Sperren erworben. Spanner verwendet verschiedene Sperrmodi, um die Anzahl der Transaktionen zu maximieren, die zu einem bestimmten Zeitpunkt Zugriff auf eine bestimmte Datenzelle haben. Unterschiedliche Sperren haben unterschiedliche Eigenschaften. Beispielsweise können einige Sperren von mehreren Transaktionen gemeinsam genutzt werden, andere hingegen nicht.
Ein Sperrkonflikt kann auftreten, wenn Sie versuchen, einen der folgenden Sperrmodi in einer Transaktion zu erhalten.
ReaderShared-Sperre: Eine Sperre, die anderen Lesevorgängen den Zugriff auf die Daten ermöglicht, bis Ihre Transaktion bereit zum Commit ist. Diese gemeinsame Sperre wird erworben, wenn eine Lese-/Schreibtransaktion Daten liest.WriterShared-Sperre: Diese Sperre wird erworben, wenn eine Lese-/Schreibtransaktion versucht, einen Schreibvorgang zu committen.Exclusive-Sperre: Eine exklusive Sperre wird erworben, wenn eine Lese-/Schreibtransaktion, die bereits eine ReaderShared-Sperre erworben hat, nach Abschluss des Lesevorgangs versucht, Daten zu schreiben. Eine exklusive Sperre ist ein Upgrade einerReaderShared-Sperre. Eine exklusive Sperre ist ein Sonderfall einer Transaktion, bei der sowohl dieReaderShared-Sperre als auch dieWriterShared-Sperre gleichzeitig gehalten werden. Keine andere Transaktion kann eine Sperre für dieselbe Zelle erhalten.WriterSharedTimestamp-Sperre: Ein spezieller Typ vonWriterShared-Sperre, der beim Einfügen neuer Zeilen in eine Tabelle erworben wird, die einen Commit-Zeitstempel als Teil des Primärschlüssels hat. Diese Art von Sperre verhindert, dass Transaktionsteilnehmer genau dieselbe Zeile erstellen und somit miteinander in Konflikt geraten. Cloud Spanner aktualisiert den Schlüssel der eingefügten Zeile, sodass er mit dem Commit-Zeitstempel der Transaktion übereinstimmt, die den Einfügevorgang ausgeführt hat.
Weitere Informationen zu Transaktionstypen und den verfügbaren Sperren finden Sie unter Transaktionen.
Konflikte mit Sperrmodus
Die folgende Tabelle zeigt die möglichen Konflikte zwischen verschiedenen Sperrmodi.
| Sperrmodi | ReaderShared |
WriterShared |
Exclusive |
WriterSharedTimestamp |
|---|---|---|---|---|
ReaderShared |
Nein | Ja | Ja | Ja |
WriterShared |
Ja | Nein | Ja | Nicht zutreffend |
Exclusive |
Ja | Ja | Ja | Nicht zutreffend |
WriterSharedTimestamp |
Ja | Nicht zutreffend | Nicht zutreffend | Ja |
WriterSharedTimestamp-Sperren werden nur verwendet, wenn neue Zeilen mit einem Zeitstempel als Teil des Primärschlüssels eingefügt werden. Die Sperren WriterShared und Exclusive werden verwendet, wenn in vorhandene Zellen geschrieben oder neue Zeilen ohne Zeitstempel eingefügt werden. Daher kann WriterSharedTimestamp nicht mit anderen Arten von Sperren in Konflikt stehen und diese Szenarien werden in der obigen Tabelle als Nicht zutreffend angezeigt.
Die einzige Ausnahme ist ReaderShared, das auf nicht vorhandene Zeilen angewendet werden kann und daher mit WriterSharedTimestamp in Konflikt stehen kann. Beispiel: Ein vollständiger Tabellenscan sperrt die gesamte Tabelle auch für Zeilen, die noch nicht erstellt wurden. Daher kann ReaderShared mit WriterSharedTimestamp in Konflikt stehen.
Was ist ein Startschlüssel für einen Zeilenbereich?
Die Spalte ROW_RANGE_START_KEY gibt den zusammengesetzten Primärschlüssel an oder beginnt den Primärschlüssel eines Zeilenbereichs mit Sperrenkonflikten. Das folgende Schema dient zur Veranschaulichung eines Beispiels.
CREATE TABLE Singers (
SingerId INT64 NOT NULL,
FirstName STRING(1024),
LastName STRING(1024),
SingerInfo BYTES(MAX),
) PRIMARY KEY (SingerId);
CREATE TABLE Albums (
SingerId INT64 NOT NULL,
AlbumId INT64 NOT NULL,
AlbumTitle STRING(MAX),
) PRIMARY KEY (SingerId, AlbumId),
INTERLEAVE IN PARENT Singers ON DELETE CASCADE;
CREATE TABLE Songs (
SingerId INT64 NOT NULL,
AlbumId INT64 NOT NULL,
TrackId INT64 NOT NULL,
SongName STRING(MAX),
) PRIMARY KEY (SingerId, AlbumId, TrackId),
INTERLEAVE IN PARENT Albums ON DELETE CASCADE;
CREATE TABLE Users (
UserId INT64 NOT NULL,
LastAccess TIMESTAMP NOT NULL OPTIONS (allow_commit_timestamp=true),
...
) PRIMARY KEY (UserId, LastAccess);
Wie die folgende Tabelle mit den Zeilenschlüsseln und Zeilenschlüsselbereichen zeigt, wird ein Bereich durch das Pluszeichen "+" angezeigt. Der Schlüssel in diesen Fällen stellt den Startschlüssel eines Schlüsselbereichs dar, in dem ein Sperrkonflikt aufgetreten ist.
| ROW_RANGE_START_KEY | Erklärung |
|---|---|
| Singers(2) | Tabelle "Singers" bei Schlüssel "SingerId=2" |
| Alben(2,1) | Album-Tabelle bei Schlüssel SingerId=2,AlbumId=1 |
| Songs(2,1,5) | Tabelle "Songs" unter dem Schlüssel "SingerId=2,AlbumId=1,TrackId=5" |
| Songs(2,1,5+) | Schlüsselbereich der Songstabelle, beginnend bei SingerId=2,AlbumId=1,TrackId=5 |
| Alben(2,1+) | Album-Tabellenschlüsselbereich ab SingerId=2,AlbumId=1 |
| Nutzer(3, 2020-11-01 12:34:56.426426+00:00) | Nutzertabelle bei Schlüssel "UserId=3, LastAccess=commit_timestamp" |
Zusammengefasste Statistiken
SPANNER_SYS enthält auch Tabellen zum Speichern aggregierter Daten für Sperrstatistiken, die von Spanner in einem bestimmten Zeitraum erfasst wurden:
SPANNER_SYS.LOCK_STATS_TOTAL_MINUTE: Zusammengefasste Statistiken für alle Sperrwartezeiten in 1-Minuten-Intervallen.SPANNER_SYS.LOCK_STATS_TOTAL_10MINUTE: Zusammengefasste Statistiken für alle Sperrzeiten in 10-Minuten-IntervallenSPANNER_SYS.LOCK_STATS_TOTAL_HOUR: Zusammengefasste Statistiken für alle Sperrzeiten in 1-Stunden-Intervallen.
Zusammengefasste Statistiktabellen haben die folgenden Eigenschaften:
Jede Tabelle enthält Daten für nicht überlappende Zeitintervalle der Länge, die im Tabellennamen angegeben ist.
Die Intervalle beziehen sich auf die Uhrzeit. 1-Minuten-Intervalle enden nach einer vollen Minute, 10-Minuten-Intervalle enden alle 10 Minuten ab Beginn der vollen Stunde, 1-Stunden-Intervalle enden zu jeder vollen Stunde.
Zum Beispiel sind um 11:59:30 Uhr die neuesten Intervalle, die für SQL-Abfragen zu zusammengefassten Sperrstatistiken zur Verfügung stehen:
- 1 Minute: 11:58:00–11:58:59 Uhr
- 10 Minuten: 11:40:00–11:49:59 Uhr
- 1 Stunde: 10:00:00–10:59:59 Uhr
Jede Zeile enthält Statistiken für alle Sperrwartezeiten in der Datenbank während des angegebenen Intervalls, die zusammengefasst werden. Es gibt nur je eine Zeile pro Zeitintervall.
Die in den
SPANNER_SYS.LOCK_STATS_TOTAL_*-Tabellen erfassten Statistiken enthalten Sperrwartezeiten, die Spanner nicht in denSPANNER_SYS.LOCK_STATS_TOP_*-Tabellen erfasst hat.Einige Spalten in diesen Tabellen werden in Cloud Monitoring als Messwerte angezeigt. Die bereitgestellten Messwerte sind:
- Wartezeit bei Sperren
Weitere Informationen finden Sie unter Spanner-Messwerte.
Tabellenschema
| Spaltenname | Typ | Beschreibung |
|---|---|---|
INTERVAL_END |
TIMESTAMP |
Ende des Zeitintervalls, in dem der Sperrkonflikt aufgetreten ist. |
TOTAL_LOCK_WAIT_SECONDS |
FLOAT64 |
Gesamtwartezeit für Sperrungen für Sperrkonflikte, die für die gesamte Datenbank aufgezeichnet wurden, in Sekunden. |
LOCK_WAIT_DISTRIBUTION |
ARRAY<STRUCT> |
Ein Histogramm der einzelnen Wartezeiten bei Sperren für Sperrenkonflikte, die für die gesamte Datenbank aufgezeichnet wurden, in Mikrosekunden, nicht in Sekunden. Die Struktur ist mit der Spalte LOCK_WAIT_DISTRIBUTION in den SPANNER_SYS.LOCK_STATS_TOP_*-Tabellen identisch. Datenbanken im PostgreSQL-Dialekt unterstützen diese Spalte nicht. Verwenden Sie stattdessen die Spalte LOCK_WAIT_DISTRIBUTION_JSON_STRING. |
LOCK_WAIT_DISTRIBUTION_JSON_STRING |
STRING |
Eine JSON-kompatible Stringdarstellung der Spalte LOCK_WAIT_DISTRIBUTION. Die Werte werden in Mikrosekunden angegeben. Diese Spalte wird in Datenbanken im GoogleSQL- und PostgreSQL-Dialekt unterstützt. |
Beispielabfragen
Das folgende Beispiel zeigt eine SQL-Anweisung, mit der Sie Sperrstatistiken abrufen können. Sie können diese SQL-Anweisungen mit den Clientbibliotheken, der gcloud spanner oder der Google Cloud Console ausführen.
Sperrstatistiken für das vorherige 1-Minuten-Intervall auflisten
Die folgende Abfrage gibt die Informationen zur Sperre für jeden Zeilenschlüssel mit einem Sperrkonflikt zurück, einschließlich des Anteils der Gesamtsperrekonflikte während des letzten 1-Minuten-Zeitintervalls.
Die Funktion CAST() konvertiert das BYTES-Feld "row_range_start_key" in einen STRING.
SELECT CAST(s.row_range_start_key AS STRING) AS row_range_start_key,
t.total_lock_wait_seconds,
s.lock_wait_seconds,
s.lock_wait_seconds/t.total_lock_wait_seconds frac_of_total,
s.sample_lock_requests
FROM spanner_sys.lock_stats_total_minute t, spanner_sys.lock_stats_top_minute s
WHERE t.interval_end =
(SELECT MAX(interval_end)
FROM spanner_sys.lock_stats_total_minute)
AND s.interval_end = t.interval_end
ORDER BY s.lock_wait_seconds DESC;
Screenshot: Ausgabe der Abfrage
| row_range_start_key | total_lock_wait_seconds | lock_wait_seconds | frac_of_total | sample_lock_requests |
|---|---|---|---|---|
| Songs(2,1,1) | 2,37 | 1,76 | 0,7426 | LOCK_MODE: ReaderShared SPALTE: Singers.SingerInfo LOCK_MODE: WriterShared Spalte: Singers.SingerInfo |
| Nutzer(3, 2020-11-01 12:34:56.426426+00:00) | 2,37 | 0,61 | 0,2573 | LOCK_MODE: ReaderShared SPALTE: users._exists1 LOCK_MODE: WriterShared SPALTE: users._exists1 |
1 _exists ist ein internes Feld, mit dem geprüft wird, ob eine bestimmte Zeile vorhanden ist.
Datenaufbewahrung
Spanner bewahrt Daten für jede Tabelle mindestens für die folgenden Zeiträume auf:
SPANNER_SYS.LOCK_STATS_TOP_MINUTEundSPANNER_SYS.LOCK_STATS_TOTAL_MINUTE: Intervalle der letzten 6 Stunden.SPANNER_SYS.LOCK_STATS_TOP_10MINUTEundSPANNER_SYS.LOCK_STATS_TOTAL_10MINUTE: Intervalle der letzten 4 Tage.SPANNER_SYS.LOCK_STATS_TOP_HOURundSPANNER_SYS.LOCK_STATS_TOTAL_HOUR: Intervalle für die letzten 30 Tage.
Sperrkonflikte in Ihrer Datenbank mithilfe von Sperrstatistiken beheben
Sie können SQL oder das Dashboard Sperrstatistiken verwenden, um Sperrkonflikte in Ihrer Datenbank aufzurufen.
In den folgenden Themen wird gezeigt, wie Sie solche Sperrkonflikte mithilfe von SQL-Code untersuchen können.
Wählen Sie einen Zeitraum aus, der untersucht werden soll.
Sie prüfen die Latenzmesswerte für Ihre Spanner-Datenbank und stellen fest, dass Ihre Anwendung in einem bestimmten Zeitraum eine hohe Latenz und CPU-Auslastung aufweist. Das Problem trat beispielsweise am 12. November 2020 gegen 22:50 Uhr auf.
Ermitteln, ob die Latenz für das Transaktions-Commit im ausgewählten Zeitraum zusammen mit der Wartezeit bei Sperren gestiegen ist
Sperren werden von Transaktionen abgerufen. Wenn Sperrkonflikte lange Wartezeiten verursachen, sollten wir neben der Erhöhung der Wartezeit für die Sperre auch eine Erhöhung der Commit-Latenz der Transaktion erkennen können.
Nachdem ein Zeitraum zum Starten der Prüfung ausgewählt wurde, führen wir die Transaktionsstatistiken TXN_STATS_TOTAL_10MINUTE mit den Sperrstatistiken LOCK_STATS_TOTAL_10MINUTE zusammen, um uns bei der Ermittlung zu unterstützen, ob die Erhöhung der durchschnittlichen Commit-Latenz durch die Erhöhung der Wartezeit der Sperre ausgelöst wird.
SELECT t.interval_end, t.avg_commit_latency_seconds, l.total_lock_wait_seconds
FROM spanner_sys.txn_stats_total_10minute t
LEFT JOIN spanner_sys.lock_stats_total_10minute l
ON t.interval_end = l.interval_end
WHERE
t.interval_end >= "2020-11-12T21:50:00Z"
AND t.interval_end <= "2020-11-12T23:50:00Z"
ORDER BY interval_end;
Nehmen wir die folgenden Daten als Beispiel für die Ergebnisse, die wir aus unserer Abfrage erhalten.
| interval_end | avg_commit_latency_seconds | total_lock_wait_seconds |
|---|---|---|
| 2020-11-12 21:40:00-07:00 | 0,002 | 0,090 |
| 2020-11-12 21:50:00-07:00 | 0,003 | 0,110 |
| 2020-11-12 22:00:00-07:00 | 0,002 | 0,100 |
| 2020-11-12 22:10:00-07:00 | 0,002 | 0,080 |
| 2020-11-12 22:20:00-07:00 | 0,030 | 0,240 |
| 2020-11-12 22:30:00-07:00 | 0,034 | 0,220 |
| 2020-11-12 22:40:00-07:00 | 0,034 | 0,218 |
| 2020-11-12 22:50:00-07:00 | 3,741 | 780,193 |
| 2020-11-12 23:00:00-07:00 | 0,042 | 0,240 |
| 2020-11-12 23:10:00-07:00 | 0,038 | 0,129 |
| 2020-11-12 23:20:00-07:00 | 0,021 | 0,128 |
| 2020-11-12 23:30:00-07:00 | 0,038 | 0,231 |
Die vorherigen Ergebnisse zeigen einen dramatischen Anstieg von avg_commit_latency_seconds und total_lock_wait_seconds im selben Zeitraum von 2020-11-12 22:40:00 bis 2020-11-12 22:50:00 und danach einen Rückgang. Beachten Sie, dass avg_commit_latency_seconds die durchschnittliche Zeit ist, die nur für den Commit-Schritt aufgewendet wird. total_lock_wait_seconds ist jedoch die zusammengefasste Sperrzeit für den Zeitraum, sodass die Zeit viel länger als die Commit-Zeit der Transaktion dauert.
Nachdem wir bestätigt haben, dass die Wartezeit für Sperren eng mit der Erhöhung der Schreiblatenz zusammenhängt, untersuchen wir im nächsten Schritt, welche Zeilen und Spalten die lange Wartezeit verursachen.
Hier erfahren Sie, welche Zeilenschlüssel und Spalten im ausgewählten Zeitraum lange Wartezeiten für Sperren hatten.
Um herauszufinden, für welche Zeilenschlüssel und Spalten in dem von uns untersuchten Zeitraum die hohen Sperrzeiten aufgetreten sind, fragen wir dieLOCK_STAT_TOP_10MINUTE Table. Diese Tabelle enthält die Zeilenschlüssel und Spalten, die am meisten zum Sperren warten.
Die Funktion CAST() in der folgenden Abfrage wandelt das BYTES-Feld "row_range_start_key" in einen STRING um.
SELECT CAST(s.row_range_start_key AS STRING) AS row_range_start_key,
t.total_lock_wait_seconds,
s.lock_wait_seconds,
s.lock_wait_seconds/t.total_lock_wait_seconds frac_of_total,
s.sample_lock_requests
FROM spanner_sys.lock_stats_total_10minute t, spanner_sys.lock_stats_top_10minute s
WHERE
t.interval_end = "2020-11-12T22:50:00Z" and s.interval_end = t.interval_end;
| row_range_start_key | total_lock_wait_seconds | lock_wait_seconds | frac_of_total | sample_lock_requests |
|---|---|---|---|---|
| Singers(32) | 780,193 | 780,193 | 1 | LOCK_MODE: WriterShared SPALTE: Singers.SingerInfo LOCK_MODE: ReaderShared SPALTE: Singers.SingerInfo |
In dieser Ergebnistabelle sehen Sie, dass der Konflikt in der Tabelle Singers unter dem Schlüssel SingerId=32 aufgetreten ist. Die Singers.SingerInfo ist die Spalte, in der der Sperrkonflikt zwischen ReaderShared und WriterShared aufgetreten ist.
Dies ist ein häufiger Konflikttyp, wenn eine Transaktion versuchen, eine bestimmte Zelle zu lesen, und die andere Transaktion versucht, in dieselbe Zelle zu schreiben. Wir kennen jetzt die genaue Datenzelle, für die die Transaktionen die Sperre beanspruchen. Im nächsten Schritt identifizieren wir die Transaktionen, die die Sperren beanspruchen.
Feststellen, welche Transaktionen auf die Spalten zugreifen, die am Sperrkonflikt beteiligt sind
Wenn Sie die Transaktionen ermitteln möchten, bei denen innerhalb eines bestimmten Zeitintervalls aufgrund von Sperrkonflikten eine erhebliche Commit-Latenz auftritt, müssen Sie die folgenden Spalten aus der Tabelle SPANNER_SYS.TXN_STATS_TOTAL_10MINUTE abfragen:
fprintread_columnswrite_constructive_columnsavg_commit_latency_seconds
Sie müssen nach gesperrten Spalten filtern, die in der Tabelle SPANNER_SYS.LOCK_STATS_TOP_10MINUTE identifiziert wurden:
Transaktionen, die eine Spalte lesen, bei der beim Versuch, die
ReaderShared-Sperre zu erhalten, ein Sperrkonflikt aufgetreten ist.Transaktionen, die in eine Spalte schreiben, bei der beim Versuch, eine
WriterShared-Sperre zu erhalten, ein Sperrkonflikt aufgetreten ist.
SELECT
fprint,
read_columns,
write_constructive_columns,
avg_commit_latency_seconds
FROM spanner_sys.txn_stats_top_10minute t2
WHERE (
EXISTS (
SELECT * FROM t2.read_columns columns WHERE columns IN (
SELECT DISTINCT(req.COLUMN)
FROM spanner_sys.lock_stats_top_10minute t, t.SAMPLE_LOCK_REQUESTS req
WHERE req.LOCK_MODE = "ReaderShared" AND t.interval_end ="2020-11-12T23:50:00Z"))
OR
EXISTS (
SELECT * FROM t2.write_constructive_columns columns WHERE columns IN (
SELECT DISTINCT(req.COLUMN)
FROM spanner_sys.lock_stats_top_10minute t, t.SAMPLE_LOCK_REQUESTS req
WHERE req.LOCK_MODE = "WriterShared" AND t.interval_end ="2020-11-12T23:50:00Z"))
)
AND t2.interval_end ="2020-11-12T23:50:00Z"
ORDER BY avg_commit_latency_seconds DESC;
Das Abfrageergebnis wird nach der Spalte avg_commit_latency_seconds sortiert, sodass die Transaktion mit der höchsten Commit-Latenz zuerst angezeigt wird.
| fprint | read_columns | write_constructive_columns | avg_commit_latency_seconds |
|---|---|---|---|
| 1866043996151916800 |
['Singers.SingerInfo', 'Singers.FirstName', 'Singers.LastName', 'Singers._exists'] |
['Singers.SingerInfo'] | 4,89 |
| 4168578515815911936 | [] | ['Singers.SingerInfo'] | 3,65 |
In den Abfrageergebnissen sehen Sie, dass zwei Transaktionen versucht haben, auf die Spalte Singers.SingerInfo zuzugreifen. Das ist die Spalte, in der im angegebenen Zeitraum Sperrkonflikte aufgetreten sind. Sobald Sie die Transaktionen identifiziert haben, die die Sperrkonflikte verursacht haben, können Sie die Transaktionen anhand ihres Fingerabdrucks fprint analysieren, um potenzielle Probleme zu identifizieren, die zum Sperrkonflikt beigetragen haben.
Nachdem Sie die Transaktion mit fprint=1866043996151916800 geprüft haben, können Sie anhand der Spalten read_columns und write_constructive_columns ermitteln, welcher Teil Ihres Anwendungscodes die Transaktion ausgelöst hat. Anschließend können Sie die zugrunde liegende DML aufrufen, die nicht nach dem Primärschlüssel SingerId filtert. Dies führte zu einem vollständigen Tabellenscan und die Tabelle wurde gesperrt, bis die Transaktion abgeschlossen war.
So lösen Sie den Sperrkonflikt:
- Verwenden Sie eine schreibgeschützte Transaktion, um die erforderlichen
SingerId-Werte zu ermitteln. - Verwenden Sie eine separate Lese-/Schreibtransaktion, um die Zeilen für die erforderlichen
SingerId-Werte zu aktualisieren.
Best Practices zur Reduzierung von Sperrkonflikten anwenden
In unserem Beispielszenario haben wir Sperrstatistiken und Transaktionsstatistiken verwendet, um das Problem auf eine Transaktion einzugrenzen, die beim Aktualisieren nicht den Primärschlüssel unserer Tabelle verwendet hat. Wir haben Ideen zur Verbesserung der Transaktion entwickelt, je nachdem, ob wir die Schlüssel der zu aktualisierenden Zeilen im Voraus kannten oder nicht.
Beachten Sie diese Best Practices, um die Anzahl von Sperrkonflikten in Ihrer Datenbank zu reduzieren, wenn Sie potenzielle Probleme in Ihrer Lösung betrachten oder auch beim Entwerfen Ihrer Lösung.
Verwenden Sie nach Möglichkeit Transaktionen mit Lesezugriff, da sie keine Sperren erwerben.
Vermeiden Sie vollständige Tabellenscans in einer Lese-Schreib-Transaktion. Dazu gehört das Schreiben einer DML-Bedingung für den Primärschlüssel oder die Zuweisung eines bestimmten Schlüsselbereichs bei Verwendung der Lese-API.
Halten Sie die Sperrzeit kurz, indem Sie die Änderung so schnell wie möglich nach dem Lesen der Daten in einer Lese-/Schreibtransaktion übernehmen. Eine Lese-/Schreibtransaktion garantiert, dass die Daten nach dem Lesen unverändert bleiben, bis Sie die Änderung erfolgreich übertragen. Dazu müssen die Datenzellen während des Lesens und des Commits gesperrt werden. Wenn Sie die Sperrzeit kurz halten, ist die Wahrscheinlichkeit von Sperrkonflikten bei Transaktionen geringer.
Bevorzugen Sie kleine Transaktionen gegenüber großen Transaktionen oder partitionierte DML für lang andauernde DML-Transaktionen. Eine Transaktion mit langer Laufzeit erhält eine Sperre für eine lange Zeit. Daher sollten Sie eine Transaktion, die Tausende von Zeilen betrifft, nach Möglichkeit in mehrere kleinere Transaktionen aufteilen, die Hunderte von Zeilen aktualisieren.
Wenn Sie die von einer Lese-Schreib-Transaktion bereitgestellte Garantie nicht benötigen, sollten Sie vor dem Commit der Änderung keine Daten in der Lese-Schreib-Transaktion lesen, z. B. durch Lesen der Daten in einer separaten schreibgeschützten Transaktion. Die meisten Sperrkonflikte treten aufgrund der starken Garantie auf, um sicherzustellen, dass die Daten zwischen dem Lese- und Commit unverändert bleiben. Wenn die Lese-/Schreibtransaktion also keine Daten liest, müssen die Zellen nicht lange gesperrt werden.
Geben Sie nur die Mindestanzahl von Spalten an, die in einer Lese-/Schreibtransaktion erforderlich sind. Da Cloud Spanner-Sperren pro Datenzelle gelten, wird bei einer Lese-/Schreibtransaktion, die zu viele Spalten liest, eine
ReaderShared-Sperre für diese Zellen erworben. Dies kann zu Sperrkonflikten führen, wenn andere Transaktionen eineWriterShared-Sperre für Schreibvorgänge in den übermäßigen Spalten erhalten. Sie können beispielsweise beim Lesen eine Reihe von Spalten anstelle von*angeben.Minimieren Sie API-Aufrufe in einer Lese-/Schreibtransaktion. Die Latenz von API-Aufrufen kann zu Sperrkonflikten in Spanner führen, da API-Aufrufe sowohl Netzwerkverzögerungen als auch dienstseitigen Verzögerungen unterliegen. Wir empfehlen, API-Aufrufe nach Möglichkeit außerhalb von Lese-/Schreibtransaktionen auszuführen. Wenn Sie API-Aufrufe innerhalb einer Lese-/Schreibtransaktion ausführen müssen, sollten Sie die Latenz Ihrer API-Aufrufe im Blick behalten, um die Auswirkungen auf die Sperrzeit zu minimieren.
Orientieren Sie sich an den Best Practices für Schemadesign.
Wenn die Möglichkeit eines Schreib-Skews für Ihre Anwendung kein Problem darstellt, sollten Sie die Isolation „Wiederholbares Lesen“ mit der standardmäßigen optimistischen Nebenläufigkeit verwenden, um Lese-/Schreibkonflikte zu vermeiden. Weitere Informationen finden Sie unter Isolation wiederholbarer Lesevorgänge.
Für Arbeitslasten mit geringem Lese-/Schreibkonflikt sollten Sie die serialisierbare Isolation mit optimistischer Nebenläufigkeitserkennung verwenden, um zu vermeiden, dass Sperren in Transaktionen bis zum Commit-Zeitpunkt erworben werden. Gleichzeitig wird erzwungen, dass alle Lesevorgänge der Transaktion zum Commit-Zeitpunkt gültig sind. Weitere Informationen zur Eignung dieser Option finden Sie unter Optimistische Nebenläufigkeitserkennung.
Nächste Schritte
- Weitere Informationen zu Tools zur Selbstbeobachtung
- Mehr über die weiteren Informationen erfahren, die Spanner für jede Datenbank in der Informationsschematabelle der Datenbank speichert
- SQL-Best-Practices für Spanner