Tiefgreifendes Verständnis langer MySQL-Transaktionen

Tiefgreifendes Verständnis langer MySQL-Transaktionen

Vorwort:

Dieser Artikel stellt hauptsächlich den Inhalt im Zusammenhang mit langen MySQL-Transaktionen vor. Was passiert beispielsweise, wenn wir eine Transaktion starten, diese aber nicht festgeschrieben oder zurückgesetzt wurde? Wie sollten wir mit der Wartesituation bei Transaktionen umgehen? Dieser Artikel gibt Ihnen die Antwort.

Hinweis: In diesem Artikel geht es nicht um die Erörterung von Transaktionsisolationsebenen und verwandten Funktionen. Stattdessen werden die mit Langzeittransaktionen verbundenen Gefahren sowie deren Überwachung und Handhabung vorgestellt. Dieser Artikel basiert auf Experimenten, die mit MySQL Version 5.7.23 und der Isolationsebene „Non-Repeatable Read“ (RR) durchgeführt wurden. (Die \G-Syntax kann verwendet werden, um die Abfragestruktur lesbarer zu machen, sie kann jedoch nur von der MySQL-Befehlszeile aus verwendet werden.)

1. Was ist eine Long-Transaktion?

Zunächst müssen wir wissen, was eine lange Transaktion ist. Wie der Name schon sagt, handelt es sich um eine Transaktion, die lange ausgeführt wird und für lange Zeit nicht festgeschrieben wird. Sie kann auch als große Transaktion bezeichnet werden. Diese Art von Transaktion verursacht häufig viele Blockierungen und Sperrzeitüberschreitungen, was leicht zu Master-Slave-Verzögerungen führen kann. Versuchen Sie, lange Transaktionen zu vermeiden.

Im Folgenden werde ich zeigen, wie man eine Transaktion startet und eine lange Transaktion simuliert:

#Angenommen, wir haben eine stu_tb-Tabelle mit der folgenden Struktur und den folgenden Daten mysql> show create table stu_tb\G
*************************** 1. Reihe ***************************
    Tabelle: stu_tb
Tabelle erstellen: CREATE TABLE `stu_tb` (
 `increment_id` int(11) NOT NULL AUTO_INCREMENT COMMENT 'Primärschlüssel automatisch inkrementieren',
 `stu_id` int(11) NOT NULL KOMMENTAR 'Studenten-ID',
 `stu_name` varchar(20) DEFAULT NULL COMMENT 'Studentenname',
 `create_time` Zeitstempel NICHT NULL STANDARD CURRENT_TIMESTAMP KOMMENTAR 'Erstellungszeit',
 `update_time` Zeitstempel NICHT NULL STANDARD CURRENT_TIMESTAMP BEI UPDATE CURRENT_TIMESTAMP KOMMENTAR 'Änderungszeit',
 PRIMÄRSCHLÜSSEL (`increment_id`),
 EINZIGARTIGER SCHLÜSSEL `uk_stu_id` (`stu_id`) MIT BTREE
) ENGINE=InnoDB AUTO_INCREMENT=9 DEFAULT CHARSET=utf8 COMMENT='Test-Studententabelle'
1 Zeile im Satz (0,01 Sek.)

mysql> wähle * aus stu_tb;
+--------------+--------+----------+---------------------+---------------------+
| Inkrement-ID | Stu-ID | Stu-Name | Erstellungszeit | Aktualisierungszeit |
+--------------+--------+----------+---------------------+---------------------+
| 1 | 1001 | von1 | 15.09.2019 14:27:34 | 15.09.2019 14:27:34 |
| 2 | 1002 | dfsfd | 15.09.2019 14:27:34 | 15.09.2019 14:27:34 |
| 3 | 1003 | fdgfg | 15.09.2019 14:27:34 | 15.09.2019 14:27:34 |
| 4 | 1004 | sdfsdf | 15.09.2019 14:27:34 | 15.09.2019 14:27:34 |
| 5 | 1005 | dsfsdg | 15.09.2019 14:27:34 | 15.09.2019 14:27:34 |
| 6 | 1006 | fgd | 15.09.2019 14:27:34 | 15.09.2019 14:27:34 |
| 7 | 1007 | fgds | 15.09.2019 14:27:34 | 15.09.2019 14:27:34 |
| 8 | 1008 | dgfsa | 15.09.2019 14:27:34 | 15.09.2019 14:27:34 |
+--------------+--------+----------+---------------------+---------------------+
8 Zeilen im Satz (0,00 Sek.)

#Öffnen Sie eine Transaktion explizit, verwenden Sie begin oder start transaction
mysql> Transaktion starten;
Abfrage OK, 0 Zeilen betroffen (0,00 Sek.)

mysql> select * from stu_tb where stu_id = 1006 für Update;
+--------------+--------+----------+---------------------+---------------------+
| Inkrement-ID | Stu-ID | Stu-Name | Erstellungszeit | Aktualisierungszeit |
+--------------+--------+----------+---------------------+---------------------+
| 6 | 1006 | fgd | 15.09.2019 14:27:34 | 15.09.2019 14:27:34 |
+--------------+--------+----------+---------------------+---------------------+
1 Zeile im Satz (0,01 Sek.)

 #Wenn wir die vorherige Transaktion nicht rechtzeitig festschreiben, wird diese Transaktion zu einer langen Transaktion. Wenn andere Sitzungen mit diesen Daten arbeiten möchten, müssen sie weiter warten.

2. So finden Sie Long-Transaktionen

Wenn wir auf ein Problem beim Warten auf eine Transaktion stoßen, müssen wir zunächst die ausgeführte Transaktion finden. Die Tabelle information_schema.INNODB_TRX enthält die Transaktionsinformationen, die derzeit in InnoDB ausgeführt werden. Diese Tabelle gibt die Startzeit der Transaktion an. Mit einer kleinen Berechnung können wir die Ausführungszeit der Transaktion ermitteln.

mysql> wähle t.*,to_seconds(jetzt())-to_seconds(t.trx_started) Leerlaufzeit aus INFORMATION_SCHEMA.INNODB_TRX t \G
*************************** 1. Reihe ***************************
          trx_id: 6168
         trx_state: LÄUFT
        trx_started: 16.09.2019 11:08:27
   trx_requested_lock_id: NULL
     trx_wait_started: NULL
        trx_gewicht: 3
    trx_mysql_thread_id: 11
         trx_query: NULL
    trx_operation_state: NULL
     trx_tables_in_use: 0
     trx_tables_locked: 1
     trx_lock_structs: 3
   trx_lock_memory_bytes: 1136
      trx_rows_locked: 2
     trx_rows_modified: 0
  trx_concurrency_tickets: 0
    trx_isolation_level: WIEDERHOLBARES LESEN
     trx_unique_checks: 1
  trx_foreign_key_checks: 1
trx_last_foreign_key_error: NULL
 trx_adaptive_hash_latched: 0
 trx_adaptive_hash_timeout: 0
     trx_ist_schreibgeschützt: 0
trx_autocommit_non_locking: 0
         Leerlaufzeit: 170

Im Ergebnis wird die Leerlaufzeit berechnet. Sie stellt die Dauer der Transaktion dar. Die trx_query der Transaktion ist jedoch NUL. Das bedeutet nicht, dass die Transaktion nichts ausgeführt hat. Eine Transaktion kann mehrere SQL-Anweisungen enthalten. Wenn die SQL-Anweisung ausgeführt wird, wird sie nicht mehr angezeigt. Die aktuelle Transaktion wird ausgeführt und InnoDB weiß nicht, ob es für diese Transaktion nachfolgende SQL-Anweisungen geben wird oder wann sie festgeschrieben wird. Daher kann trx_query keine sinnvollen Informationen liefern.

Was ist, wenn wir das von dieser Transaktion ausgeführte SQL sehen möchten, um zu sehen, ob wir die lange Transaktion beenden können? Wir können es in Verbindung mit anderen Systemtabellen abfragen. Die spezifische SQL-Abfrage lautet wie folgt:

mysql> wähle now(),(UNIX_TIMESTAMP(now()) - UNIX_TIMESTAMP(a.trx_started)) diff_sec,b.id,b.user,b.host,b.db,d.SQL_TEXT aus information_schema.innodb_trx ein innerer Join
  -> information_schema.PROCESSLIST b
  -> auf a.TRX_MYSQL_THREAD_ID=b.id und b.command = 'Sleep'
  -> innerer Join performance_schema.threads c ON b.id = c.PROCESSLIST_ID
  -> innerer Join performance_schema.events_statements_current d ON d.THREAD_ID = c.THREAD_ID;
+---------------------+----------+----+------+-----------+--------+--------+-----------------------------------------------------------+
| jetzt() | diff_sec | ID | Benutzer | Host | db | SQL_TEXT |
+---------------------+----------+----+------+-----------+--------+--------+-----------------------------------------------------------+
| 16.09.2019 14:06:26 | 54 | 17 | root | localhost | testdb | select * from stu_tb where stu_id = 1006 für Update |
+---------------------+----------+----+------+-----------+--------+--------+-----------------------------------------------------------+

In den obigen Ergebnissen hat diff_sec dieselbe Bedeutung wie idle_time oben, also die Anzahl der Sekunden, die diese Transaktion dauert. SQL_TEXT gibt das gerade von der Transaktion ausgeführte SQL an. Die obige Anweisung kann jedoch nur das zuletzt in der Transaktion ausgeführte SQL finden. Wir wissen, dass eine Transaktion mehrere SQLs enthalten kann. Dann möchten wir abfragen, welche SQLs von dieser nicht festgeschriebenen Transaktion ausgeführt wurden. Kann diese Abfrage erfüllt werden? Die Antwort ist, dass sie auch durch Kombinieren der Systemtabelle events_statements_history erfüllt werden kann. Die folgende Anweisung fragt den gesamten von der Transaktion ausgeführten SQL-Befehl ab:

mysql> AUSWÄHLEN
  -> ps.id 'PROZESS-ID',
  -> ps.USER,
  -> ps.HOST,
  -> esh.EVENT_ID,
  -> trx.trx_started,
  -> esh.event_name 'EREIGNISNAME',
  -> esh.sql_text 'SQL',
  -> ps.Zeit
  -> VON
  -> PERFORMANCE_SCHEMA.events_statements_history esh
  -> JOIN PERFORMANCE_SCHEMA.threads th ON esh.thread_id = th.thread_id
  -> JOIN information_schema.PROCESSLIST ps ON ps.id = th.processlist_id
  -> LINKS JOIN information_schema.innodb_trx trx ON trx.trx_mysql_thread_id = ps.id
  -> WO
  -> trx.trx_id IST NICHT NULL
  -> UND ps.USER != 'SYSTEM_USER'
  -> BESTELLEN NACH
  ->esh.EREIGNIS_ID;
+------------+------+-----------+----------+---------------------+------------------------------------------+-----------------------------------------------------+------+
| PROZESS-ID | BENUTZER | HOST | EVENT_ID | trx_started | EREIGNISNAME | SQL | Zeit |
+------------+------+-----------+----------+---------------------+------------------------------------------+-----------------------------------------------------+------+
| 20 | root | localhost | 1 | 16.09.2019 14:18:44 | Anweisung/SQL/Auswahl | Auswahl @@version_comment Limit 1 | 60 |
| 20 | root | localhost | 2 | 16.09.2019 14:18:44 | Anweisung/SQL/Beginn | Transaktion starten | 60 |
| 20 | root | localhost | 3 | 16.09.2019 14:18:44 | Anweisung/SQL/Auswahl | SELECT DATABASE() | 60 |
| 20 | root | localhost | 4 | 16.09.2019 14:18:44 | Anweisung/com/Init DB | NULL | 60 |
| 20 | root | localhost | 5 | 16.09.2019 14:18:44 | Anweisung/SQL/Datenbanken anzeigen | Datenbanken anzeigen | 60 |
| 20 | root | localhost | 6 | 16.09.2019 14:18:44 | Anweisung/SQL/Tabellen anzeigen | Tabellen anzeigen | 60 |
| 20 | root | localhost | 7 | 16.09.2019 14:18:44 | Anweisung/com/Feldliste | NULL | 60 |
| 20 | root | localhost | 8 | 16.09.2019 14:18:44 | Anweisung/com/Feldliste | NULL | 60 |
| 20 | root | localhost | 9 | 16.09.2019 14:18:44 | Anweisung/SQL/Auswahl | Auswahl * aus stu_tb | 60 |
| 20 | root | localhost | 10 | 16.09.2019 14:18:44 | Anweisung/SQL/Auswahl | Auswahl * von stu_tb, wobei stu_id = 1006 für Aktualisierung | 60 |
+------------+------+-----------+----------+---------------------+------------------------------------------+-----------------------------------------------------+------+

Aus den obigen Ergebnissen können wir alle von der Transaktion ausgeführten SQL-Anweisungen von Anfang bis jetzt sehen. Nachdem wir alle relevanten Informationen der Transaktion abgefragt haben, können wir feststellen, ob die Transaktion abgebrochen werden kann, um zu vermeiden, dass andere Transaktionen beeinträchtigt werden und Wartezeiten entstehen.

Lassen Sie mich das etwas näher ausführen. Lange Transaktionen führen sehr wahrscheinlich zu Blockierungen oder Deadlocks. Normalerweise können wir zuerst die Ansicht sys.innodb_lock_waits abfragen, um festzustellen, ob es eine Transaktionsblockierung gibt:

#Nehmen wir an, eine Transaktion führt select * from stu_tb where stu_id = 1006 für das Update aus
#Eine andere Transaktion führt das Update stu_tb aus und setzt stu_name = 'wang', wobei stu_id = 1006

mysql> wähle * aus sys.innodb_lock_waits\G
*************************** 1. Reihe ***************************
        wait_started: 16.09.2019 14:34:32
          Wartezeit: 00:00:03
        Wartezeit_Sekunden: 3
        gesperrte_Tabelle: `testdb`.`stu_tb`
        locked_index: uk_stu_id
         gesperrter Typ: AUFZEICHNUNG
       wartende_trx_id: 6178
     waiting_trx_started: 16.09.2019 14:34:32
       Wartezeit: 00:00:03
   waiting_trx_rows_locked: 1
  waiting_trx_rows_modified: 0
         warte_pid: 19
        waiting_query: Aktualisiere stu_tb, setze stu_name = 'wang', wobei stu_id = 1006
       Wartesperren-ID: 6178:47:4:7
      Wartesperrmodus: X
       Blockierungs-TRX-ID: 6177
        Blockierungs-PID: 20
       Blockierungsabfrage: NULL
      Sperrsperr-ID: 6177:47:4:7
     Blockierungssperrmodus: X
    blocking_trx_started: 16.09.2019 14:18:44
      Blockierung_TRX_Alter: 00:15:51
  Blockierung_TRX_Zeilen_gesperrt: 2
 Blockieren von TRX-Zeilen geändert: 0
   sql_kill_blocking_query: KILL-ABFRAGE 20
sql_kill_blocking_connection: KILL 20

Die obigen Ergebnisse zeigen das blockierte SQL und den Sperrtyp. Noch leistungsfähiger ist, dass auch die Anweisung zum Beenden der Sitzung angegeben wird. Es wurde jedoch kein SQL gefunden, das die Sitzungsausführung blockiert. Wenn wir genauere Informationen erhalten möchten, können wir die folgende Anweisung verwenden:

mysql> AUSWÄHLEN
  -> temporär*,
  -> c.SQL_Text blockierender_SQL_Text,
  -> p.HOST blockierender_Host
  -> VON
  -> (
  -> AUSWÄHLEN
  -> r.trx_state beobachtet_trx_state,
  -> r.trx_id warte_trx_id,
  -> r.trx_mysql_thread_Id Wartethread,
  -> r.trx_query warte_abfrage,
  -> b.trx_state Blockierungs-TRX_State,
  -> b.trx_id blockierende_trx_id,
  -> b.trx_mysql_thread_id blockierender Thread,
  -> b.trx_query blockierende_Abfrage
  -> VON
  -> information_schema.innodb_lock_waits w
  -> INNER JOIN information_schema.innodb_trx b ON b.trx_id = w.blocking_trx_id
  -> INNER JOIN information_schema.innodb_trx r ON r.trx_id = w.requesting_trx_id
  -> ) tmp,
  -> information_schema.PROCESSLIST p,
  -> PERFORMANCE_SCHEMA.events_statements_current c,
  -> PERFORMANCE_SCHEMA.threads t
  -> WO
  -> tmp.blocking_thread = p.id
  -> UND t.thread_id = c.THREAD_ID
  -> UND t.PROCESSLIST_ID = p.id \G
*************************** 1. Reihe ***************************
 watching_trx_state: SPERRE WARTEN
  wartende_trx_id: 6180
  Wartethread: 19
   waiting_query: Aktualisiere stu_tb, setze stu_name = 'wang', wobei stu_id = 1006
blocking_trx_state: LÄUFT
  Blockierungs-TRX-ID: 6177
  blockierender_Thread: 20
  Blockierungsabfrage: NULL
 blocking_sql_text: wähle * aus stu_tb, wobei stu_id = 1006 für Update
   blockierender_Host: lokaler Host

Die obigen Ergebnisse sind klarer. Wir können die von den blockierenden und blockierten Transaktionen ausgeführten Anweisungen deutlich sehen, was uns bei der Fehlerbehebung hilft und uns hilft zu bestätigen, ob die blockierte Sitzung beendet werden kann.

3. Überwachen Sie lange Transaktionen

In der Praxis müssen wir lange Transaktionen überwachen und einen Schwellenwert festlegen, beispielsweise 30 Sekunden. Transaktionen, deren Ausführung länger als 30 Sekunden dauert, sind lange Transaktionen und müssen aufgezeichnet und gemeldet werden, um das Managementpersonal an die Bearbeitung zu erinnern. Das Überwachungsskript ist unten aufgeführt. Sie können es zu Rate ziehen und nach Bedarf ändern:

#!/bin/bash
# -----------------------------------------------------------------------------------
# Dateiname: long_trx.sh
# Beschreiben Sie: Überwachung langer Transaktionen
# Revision: 1.0
# Datum: 16.09.2019
# Autor: wang

/usr/local/mysql/bin/mysql -N -uroot -pxxxxxx -e "select now(),(UNIX_TIMESTAMP(now()) - UNIX_TIMESTAMP(a.trx_started)) diff_sec,b.id,b.user,b.host,b.db,d.SQL_TEXT aus information_schema.innodb_trx ein innerer Join
information_schema.PROCESSLIST b
bei a.TRX_MYSQL_THREAD_ID=b.id und b.command = 'Sleep'
Innerer Join performance_schema.threads c ON b.id = c.PROCESSLIST_ID
innerer Join performance_schema.events_statements_current d ON d.THREAD_ID = c.THREAD_ID;" | während des Lesens ABCDEFGH
Tun
 wenn [ "$C" -gt 30 ]
   Dann
   echo $(Datum +"%J-%m-%d %H:%M:%S")
   echo "Prozess-ID[$D] $E@$F in db[$G] halte Transaktionszeit $C SQL:$H"
 fi
fertig >> /tmp/longtransaction.txt

Zur kurzen Erklärung: -gt 30 bedeutet hier 30 Sekunden. Wenn es 30 Sekunden überschreitet, wird es als lange Transaktion betrachtet. Sie können es entsprechend den tatsächlichen Anforderungen anpassen. Fügen Sie das Skript der geplanten Aufgabe hinzu und es wird ausgeführt.

Zusammenfassen:

In diesem Artikel werden hauptsächlich Inhalte zu langen Transaktionen sowie die Suche nach langen Transaktionen, der Umgang mit langen Transaktionen und die Überwachung langer Transaktionen vorgestellt. Vielleicht wissen einige von Ihnen nicht viel über Transaktionen. Ich hoffe, dieser Artikel wird Ihnen hilfreich sein. Da in diesem Artikel viele Anweisungen zu Abfragetransaktionen aufgelistet sind, werden sie wie folgt zusammengefasst:

# Alle laufenden Transaktionen und deren Laufzeit abfragen select t.*,to_seconds(now())-to_seconds(t.trx_started) idle_time from INFORMATION_SCHEMA.INNODB_TRX t \G

# Transaktionsdetails abfragen und SQL ausführen
Wählen Sie jetzt (), (UNIX_TIMESTAMP (jetzt ()) - UNIX_TIMESTAMP (a.trx_started)) diff_sec, b.id, b.user, b.host, b.db, d.SQL_TEXT aus information_schema.innodb_trx ein innerer Join information_schema.PROCESSLIST b
bei a.TRX_MYSQL_THREAD_ID=b.id und b.command = 'Sleep'
Innerer Join performance_schema.threads c ON b.id = c.PROCESSLIST_ID
innerer Join performance_schema.events_statements_current d ON d.THREAD_ID = c.THREAD_ID;

# Abfrage aller historischen SQL-Datensätze, die von der Transaktion SELECT ausgeführt wurden
 ps.id 'PROZESS-ID',
 ps.BENUTZER,
 ps.HOST,
 esh.EVENT_ID,
 trx.trx_started,
 esh.event_name 'EREIGNISNAME',
 esh.sql_text 'SQL',
 ps.Zeit 
AUS
 PERFORMANCE_SCHEMA.events_statements_history esh
 JOIN PERFORMANCE_SCHEMA.threads th ON esh.thread_id = th.thread_id
 JOIN information_schema.PROCESSLIST ps ON ps.id = th.processlist_id
 LINKS JOIN information_schema.innodb_trx trx ON trx.trx_mysql_thread_id = ps.id 
WO
 trx.trx_id IST NICHT NULL 
 UND ps.USER != 'SYSTEM_USER' 
BESTELLEN BIS
 esh.EVENT_ID;
 
 # Einfache Abfrage Transaktionssperre select * from sys.innodb_lock_waits\G
 
 #Transaktionssperrdetails abfragenSELECT
 tmp.*,
 c.SQL_Text blockierender_SQL_Text,
 p.HOST blockierender_Host
AUS
 (
 WÄHLEN
  r.trx_state beobachtet_trx_state,
  r.trx_id warte_trx_id,
  r.trx_mysql_thread_Id Wartethread,
  r.trx_query warte_abfrage,
  b.trx_state Blockierender_trx_state,
  b.trx_id blockierende_trx_id,
  b.trx_mysql_thread_id blockierender Thread,
  b.trx_query blockierende_Abfrage
 AUS
  information_schema.innodb_lock_waits w
  INNER JOIN information_schema.innodb_trx b ON b.trx_id = w.blocking_trx_id
  INNER JOIN information_schema.innodb_trx r ON r.trx_id = w.requesting_trx_id 
 ) tmp,
 information_schema.PROCESSLIST p,
 PERFORMANCE_SCHEMA.events_statements_current c,
 PERFORMANCE_SCHEMA.threads t
WO
 tmp.blocking_thread = p.id 
 UND t.thread_id = c.THREAD_ID 
 UND t.PROCESSLIST_ID = p.id \G

Das Obige ist der detaillierte Inhalt für ein vertieftes Verständnis von MySQL-Langtransaktionen. Weitere Informationen zu MySQL-Langtransaktionen finden Sie in den anderen verwandten Artikeln auf 123WORDPRESS.COM!

Das könnte Sie auch interessieren:
  • Beschreiben Sie kurz die vier Transaktionsisolationsebenen von MySql
  • Verwenden von SpringBoot-Annotationen zum Verarbeiten von Transaktions-Rollbacks
  • Detaillierte Erklärung von MySQL-Transaktionen und MySQL-Protokollen
  • Detaillierte Erläuterung der SpringAOP-Transaktionskonfigurationssyntax und des Implementierungsprozesses
  • Spring-Lösung zur Ausnahmeerfassung und Rollback-Transaktion
  • So schreiben Sie elegant Transaktionscode in Golang
  • Der Aufruf der Java-Annotation @Transactional-Transaktionsklasse wird nicht wirksam und bietet eine Lösung
  • Ausführliche Erläuterung der Konzepte und Verwendung von MySQL-Transaktionen
  • So fragen Sie die neueste Transaktions-ID in MySQL ab

<<:  JavaScript zur Implementierung des Flugzeugkriegsspiels

>>:  Implementierung der Deduplizierung von Dateiinhalten sowie von Schnittmengen und Unterschieden in Linux

Artikel empfehlen

Implementierung neuer Probleme mit CSS3-Selektoren

Inhaltsverzeichnis Grundlegende Selektorerweiteru...

jQuery realisiert den Gleiteffekt des Dropdown-Menüs

Wenn wir eine Webseite erstellen, möchten wir man...

So verpacken Sie das Docker-Image, übertragen es auf den Remote-Server und stellen es auf k8s bereit

Inhaltsverzeichnis 1. Docker-Datei 2. POM-Konfigu...

Detaillierte Erklärung zum Einrichten eines DNS-Servers unter Linux

1. DNS-Server-Konzept Die Kommunikation im Intern...

Detailliertes Tutorial zur Installation von Docker und Nvidia-Docker unter Ubuntu 16.04

Inhaltsverzeichnis Docker-Installation Nvidia-Doc...

Linux-Installation MySQL5.6.24 Nutzungsanweisungen

Hinweise zur Linux-Installation von MySQL 1. Stel...

So stellen Sie War-Pakete manuell über Tomcat9 unter Windows und Linux bereit

Die Ergebnisse sind in Windows- und Linux-Umgebun...

Implementierungsschritte für Docker-Compose zum Bereitstellen eines etcd-Clusters

Inhaltsverzeichnis Schreiben Sie docker-compose.y...

Tutorial-Diagramm zur Installation von TomCat unter Windows 10

Installieren Sie TomCat unter Windows Dieser Arti...

Verwenden Sie js, um js-Funktionen in Iframe-Seiten aufzurufen

In letzter Zeit habe ich jeden Tag an meinen Absch...

Verwendung des Array-Filters filter() in JS

Inhaltsverzeichnis 1. Einleitung 2. Einführung in...

Detaillierte Erläuterung der Lösung für den Fehler bei der Verwendung von systemctl zum Starten des Dienstes im Docker

Docker-Version: [root@localhost gae_proxy]# Docke...

Unterschied zwischen den Methoden querySelector und getElementById in JS

Inhaltsverzeichnis 1. Übersicht 1.1 Verwendung vo...

JavaScript, um die Idee des Schlangenspiels umzusetzen

Die Implementierungsidee des Javascript-Spiels Sn...

Verwendung des Linux-Datumsbefehls

1. Befehlseinführung Mit dem Datumsbefehl wird di...