Detaillierte Erklärung zum Anzeigen der Anzahl der MySQL-Server-Threads

In diesem Artikel wird anhand eines Beispiels beschrieben, wie Sie die Anzahl der MySQL-Server-Threads anzeigen können. Teilen Sie uns die Einzelheiten zu Ihrer Information mit:

MySQL-Neustartbefehl:

/etc/init.d/mysql Neustart

Die Anzahl der Threads des MySQL-Servers muss in einem angemessenen Bereich liegen, um sicherzustellen, dass der MySQL-Server ordnungsgemäß und reibungslos läuft. Threads_created gibt die Anzahl der erstellten Threads an. Durch Anzeigen von Threads_created können Sie den Prozessstatus des MySQL-Servers anzeigen.

mysql> globalen Status wie „Thread%“ anzeigen;
+---------------------+------+
| Variablenname | Wert |
+---------------------+------+
| Threads_cached | 46 |
| Threads_verbunden | 2 |
| Threads_erstellt | 570 |
| Laufende Threads | 1 |
+---------------------+------+

Wenn wir thread_cache_size in der MySQL-Serverkonfigurationsdatei festlegen, wird beim Trennen der Client der Thread des Servers, der diesen Client verarbeitet, zwischengespeichert, um auf den nächsten Client zu antworten, anstatt zerstört zu werden (vorausgesetzt, die Cache-Nummer hat die Obergrenze nicht erreicht).

Threads_created gibt die Anzahl der erstellten Threads an. Wenn der Threads_created-Wert zu groß ist, bedeutet dies, dass der MySQL-Server Threads erstellt hat, was ebenfalls ressourcenintensiv ist. Sie können den thread_cache_size-Wert in der Konfigurationsdatei entsprechend erhöhen und den Server abfragen.

thread_cache_size-Konfiguration:

mysql> Variablen wie „thread_cache_size“ anzeigen;
+---------------------+------+
| Variablenname | Wert |
+---------------------+------+
| Thread-Cache-Größe | 64 |
+---------------------+------+

Der Server im Beispiel ist noch ziemlich fehlerfrei.

Analysieren Sie mehrere Parameter im Zusammenhang mit der MySQL-Verbindungsnummer

MySQL-Variablen und -Status sind leistungsstarke Tools für Verwaltung und Wartung, genau wie Oracles spfile- und v$-Tabellen.

MySQL zeichnet viele Konfigurationsinformationen über Systemvariablen auf, beispielsweise die maximale Anzahl von Verbindungen max_connections:

mysql> Variablen wie „%connect%“ anzeigen;
+--------------------------+-----------------+
| Variablenname | Wert |
+--------------------------+-----------------+
| Zeichensatzverbindung | utf8 |
| Sortierverbindung | utf8_general_ci |
| Verbindungstimeout | 10 |
| init_connect | NAMEN FESTLEGEN utf8 |
| max_Verbindungsfehler | 10 |
| max_Verbindungen | 200 |
| Max. Benutzerverbindungen | 0 |
+--------------------------+-----------------+
7 Zeilen im Satz (0,00 Sek.)

Dieser Parameter bezieht sich auf die Anzahl der Clients, die gleichzeitig eine Verbindung herstellen können. Der Standardwert in Version 5.1 ist 151. Die tatsächliche Anzahl der unterstützten Verbindungen ist dieser Wert plus eins, also 152, da eine Verbindung für den Systemadministrator reserviert ist, der sich anmeldet und Informationen anzeigt. Die Größe dieses Parameters sollte auf der Grundlage vieler Faktoren berücksichtigt werden, z. B. der Anzahl der von der verwendeten Plattform unterstützten Thread-Bibliotheken (Windows unterstützt nur bis zu 2048), der Serverkonfiguration (insbesondere der Speichergröße), der von jeder Verbindung belegten Ressourcenmenge (Speicher und Last), der vom System benötigten Antwortzeit usw. Im Allgemeinen haben Linux-Systeme kein Problem damit, Hunderte von gleichzeitigen Verbindungen zu unterstützen. Dieser Parameter kann im globalen oder Sitzungsbereich geändert werden:

mysql> globale max_connections=151 festlegen;
Abfrage OK, 0 Zeilen betroffen (0,00 Sek.)
mysql> Variablen wie „%connect%“ anzeigen;
+--------------------------+-----------------+
| Variablenname | Wert |
+--------------------------+-----------------+
| Zeichensatzverbindung | utf8 |
| Sortierverbindung | utf8_general_ci |
| Verbindungstimeout | 10 |
| init_connect | NAMEN FESTLEGEN utf8 |
| max_Verbindungsfehler | 10 |
| max_Verbindungen | 151 |
| Max. Benutzerverbindungen | 0 |
+--------------------------+-----------------+
7 Zeilen im Satz (0,00 Sek.)

Dabei ist allerdings zu beachten, dass es durch die Zunahme der Zahl der Verbindungen zu zahlreichen Kettenreaktionen kommt und die daraus resultierenden negativen Auswirkungen in der Praxis vermieden werden müssen.

Schauen wir uns zunächst die Statusausgabe an:

mysql> Status
--------------
mysql Ver 14.14 Distrib 5.1.49, für pc-linux-gnu (i686) mit readline 5.1
Verbindungs-ID: 255260
Aktuelle Datenbank: mysql
Aktueller Benutzer: root@localhost
SSL: Nicht in Verwendung
Aktueller Pager: stdout
Outfile wird verwendet: ''
Trennzeichen verwenden: ;
Serverversion: 5.1.49-log MySQL Community Server (GPL)
Protokollversion: 10
Verbindung: Localhost über UNIX-Socket
Server-Zeichensatz: utf8
DB-Zeichensatz: utf8
Client-Zeichensatz: utf8
Conn.-Zeichensatz: utf8
UNIX-Socket: /var/lib/mysql/mysql.sock
Betriebszeit: 161 Tage 3 Stunden 42 Minuten 38 Sekunden
Themen: 14 Fragen: 160655492 Langsame Abfragen: 71 Öffnungen: 8124 Tabellen leeren: 3 Tabellen öffnen: 64 Abfragen pro Sekunde im Durchschnitt: 11.538
--------------

Hier gibt es eine Open tables Ausgabe von 64, was bedeutet, dass die Anzahl der in der aktuellen Datenbank geöffneten Tabellen 64 beträgt. Es ist zu beachten, dass diese 64 nicht die tatsächlichen 64 Tabellen sind, da MySQL ein Multithread-System ist und mehrere verschiedene gleichzeitige Verbindungen dieselbe Tabelle öffnen können. Dies erfordert die Zuweisung von unabhängigem Speicherplatz für verschiedene Verbindungssitzungen, um diese Informationen zu speichern und Konflikte zu vermeiden. Daher führt eine Erhöhung der Anzahl der Verbindungen zu einer Erhöhung der Anzahl der von MySQL benötigten Dateideskriptoren. Darüber hinaus wird für MyISAM-Tabellen ein gemeinsamer Indexdateideskriptor erstellt.

Auf der Ebene der MySQL-Datenbank gibt es mehrere Systemparameter, die die Anzahl der Tabellen bestimmen, die gleichzeitig geöffnet werden können, und die zu verwendenden Dateideskriptoren, nämlich table_open_cache, max_tmp_tables und open_files_limit.

mysql> Variablen wie „table_open%“ anzeigen;
+------------------+--------+
| Variablenname | Wert |
+------------------+--------+
| Tabelle_öffnen_Cache | 64 |
+------------------+--------+
1 Zeile im Satz (0,00 Sek.)

Der Parameter table_open_cache ist hier 64, was bedeutet, dass alle MySQL-Threads gleichzeitig 64 Tabellen öffnen können. Wir können die historischen Aufzeichnungen des Systems über die Anzahl der geöffneten Tabellen sammeln und sie mit diesem Parameter vergleichen, um zu entscheiden, ob die Größe dieses Parameters erhöht werden soll. Eine Möglichkeit, die Anzahl der aktuell geöffneten Tabellen anzuzeigen, besteht in der Verwendung des oben erwähnten status . Eine andere Möglichkeit besteht darin, den Wert dieser Systemvariablen direkt abzufragen:

mysql> Status wie „open%“ anzeigen;
+--------------------------+----------+
| Variablenname | Wert |
+--------------------------+----------+
| Dateien öffnen | 3 |
| Offene_Streams | 0 |
| Tabellendefinitionen öffnen | 8 |
| Offene_Tische | 8 |
| Geöffnete_Dateien | 91768 |
| Geöffnete_Tabellendefinitionen | 0 |
| Geöffnete_Tabellen | 0 |
+--------------------------+----------+
7 Zeilen im Satz (0,00 Sek.)
mysql> globalen Status wie „open%“ anzeigen;
+--------------------------+----------+
| Variablenname | Wert |
+--------------------------+----------+
| Dateien öffnen | 3 |
| Offene_Streams | 0 |
| Tabellendefinitionen öffnen | 10 |
| Offene_Tische | 11 |
| Geöffnete_Dateien | 91791 |
| Geöffnete_Tabellendefinitionen | 1211 |
| Geöffnete_Tabellen | 8158 |
+--------------------------+----------+
7 Zeilen im Satz (0,00 Sek.)

Dabei ist Open_tables die Anzahl der aktuell geöffneten Tabellen. Die aktuell geöffnete Tabelle kann mit dem Befehl „flush tables“ geschlossen werden. Die Opened_tables stellen global betrachtet einen historischen kumulativen Wert dar. Wenn dieser Wert zu groß ist und der Befehl flush tables nicht häufig ausgeführt wird, können Sie eine Erhöhung der Größe des Parameters „table_open_cache“ in Erwägung ziehen.

Schauen Sie sich als nächstes den Parameter max_tmp_tables an:

mysql> Variablen wie „max_tmp%“ anzeigen;
+----------------+--------+
| Variablenname | Wert |
+----------------+--------+
| max_tmp_tabellen | 32 |
+----------------+--------+
1 Zeile im Satz (0,00 Sek.)

Dieser Parameter gibt die Anzahl der temporären Tabellen an, die von einer einzelnen Clientverbindung geöffnet werden können. Zeigen Sie die Informationen der aktuell geöffneten temporären Tabelle an:

mysql> globalen Status wie „%tmp%table%“ anzeigen;
+-------------------------+----------+
| Variablenname | Wert |
+-------------------------+----------+
| Temporäre Datenträgertabellen erstellt | 10478 |
| Temporäre Tabellen erstellt | 25860 |
+-------------------------+----------+
2 Zeilen im Satz (0,00 Sek.)

Sie können diese beiden Werte auch vergleichen, um zu bestimmen, wo eine temporäre Tabelle erstellt werden soll. Wenn BLOB- und TEXT-Spalten ausgewählt werden, die Datenmenge in Group by- und Distinct-Anweisungen 512 Byte überschreitet oder wenn die Daten in einer bestimmten Spalte einer Union-Auswahl 512 Byte überschreiten, wird im Allgemeinen direkt auf der Festplatte eine temporäre Tabelle erstellt. Wenn die temporäre Tabelle im Speicher größer wird, kann sie außerdem von MySQL automatisch auf die Festplatte übertragen werden (bestimmt durch die Parameter tmp_table_size und max_heap_table_size).

Um mit der ursprünglichen Diskussion fortzufahren: Wenn Sie die Größe der Parameter table_open_cache oder max_tmp_tables erhöhen, erhöht sich aus Sicht des Betriebssystems die Anzahl der Dateideskriptoren, die der mysqld-Prozess verwenden muss, entsprechend. Dies wird durch den Parameter open_files_limit gesteuert. Dieser Parameter wird jedoch durch das Betriebssystem beschränkt, sodass der von uns festgelegte Wert möglicherweise nicht immer wirksam ist. Wenn das Betriebssystem MySQL daran hindert, diesen Wert zu ändern, setzen Sie ihn auf 0. Handelt es sich um einen dedizierten MySQL-Server, sollte dieser Wert grundsätzlich möglichst groß angesetzt werden, also auf den Maximalwert, bei dem der Fehler „Zu viele offene Dateien“ nicht gemeldet wird, damit Sie das Problem ein für alle Mal lösen können. Wenn das Betriebssystem nicht genügend Dateideskriptoren zuordnen kann, zeichnet der mysqld-Prozess eine Warnmeldung im Fehlerprotokoll auf.

mysql> Variablen wie „open_files%“ anzeigen;+------------------+----------+| Variablenname | Wert |+------------------+-------+| open_files_limit | 1024 |+------------------+-------+1 Zeile im Set (0,00 Sek.)
mysql> Variablen wie „open_files%“ anzeigen;
+------------------+--------+
| Variablenname | Wert |
+------------------+--------+
| Limit für geöffnete Dateien | 1024 |
+------------------+--------+
1 Zeile im Satz (0,00 Sek.)

Entsprechend gibt es zwei Statusvariablen, die die aktuellen und historischen Dateiöffnungsinformationen aufzeichnen:

mysql> globalen Status wie „%open%file%“ anzeigen;
+---------------+-------+
| Variablenname | Wert |
+---------------+-------+
| Dateien öffnen | 3 |
| Geöffnete_Dateien | 91799 |
+---------------+-------+
2 Zeilen im Satz (0,01 Sek.)

MySQL weist Threads zu, um jede Verbindung zu handhaben. Sie können die Anzahl der aktuell zugewiesenen Threads über den Parameter threads_connected anzeigen:

mysql> Status wie „%thread%“ anzeigen;
+------------------------+--------+
| Variablenname | Wert |
+------------------------+--------+
| Verzögerte_Einfügung_von_Threads | 0 |
| Langsame Startthreads | 0 |
| Zwischengespeicherte Threads | 0 |
| Threads_verbunden | 14 |
| Threads_erstellt | 255570 |
| Laufende Threads | 2 |
+------------------------+--------+
6 Zeilen im Satz (0,00 Sek.)

Der Vergleich dieses threads_connected-Parameters mit dem oben genannten max_connections-Parameter kann auch als Referenz für die aktuelle Systemlast verwendet werden, um zu entscheiden, ob die Anzahl der Verbindungen geändert werden muss.

Wenn Sie ausführlichere Informationen zu jedem Thread anzeigen möchten, können Sie processlist verwenden:

mysql> Prozessliste anzeigen;
+--------+-----------+--------------------+----------+-------------+----------+----------------------------------------------------------------+------------------+
| ID | Benutzer | Host | db | Befehl | Zeit | Status | Info |
+--------+-----------+--------------------+----------+-------------+----------+----------------------------------------------------------------+------------------+
| 8293 | repl | 192.168.0.33:47208 | NULL | Binlog-Dump | 11574424 | Hat das gesamte Binlog an den Slave gesendet; warte auf die Aktualisierung des Binlogs | NULL |
| 140991 | mogile | 192.168.0.33:41714 | mogilefs | Schlaf | 0 | | NULL |
| 140992 | mogile | 192.168.0.33:41715 | mogilefs | Schlaf | 3 | | NULL |
| 140993 | mogile | 192.168.0.33:41722 | mogilefs | Schlaf | 2 | | NULL |
| 140994 | mogile | 192.168.0.33:41723 | mogilefs | Schlaf | 1 | | NULL |
| 140995 | mogile | 192.168.0.33:41724 | mogilefs | Schlaf | 3 | | NULL |
| 254914 | mogile | 192.168.0.33:43028 | mogilefs | Ruhezustand | 11074 | | NULL |
| 254915 | mogile | 192.168.0.33:43032 | mogilefs | Schlaf | 11091 | | NULL |
| 255144 | mogile | 192.168.0.33:47514 | mogilefs | Schlaf | 11090 | | NULL |
| 255157 | mogile | 192.168.0.33:47535 | mogilefs | Schlaf | 11087 | | NULL |
| 255162 | mogile | 192.168.0.33:47549 | mogilefs | Ruhezustand | 11074 | | NULL |
| 255260 | root | localhost | mysql | Abfrage | 0 | NULL | Prozessliste anzeigen |
| 255352 | maopaodev | 192.168.0.78:55399 | maopaodb | Schlaf | 3172 | | NULL |
| 255353 | maopaodev | 192.168.0.78:55400 | NULL | Schlafen | 8926 | | NULL |
+--------+-----------+--------------------+----------+-------------+----------+----------------------------------------------------------------+------------------+
14 Zeilen im Satz (0,00 Sek.)

Zum Ausführen dieses Befehls ist das Privileg Process_priv erforderlich. Spezifische Informationen zur Berechtigungszuweisung finden Sie in der Tabelle mysql.user.

Bei Threads, die den Systembetrieb beeinträchtigen, können Sie gnadenlos vorgehen und sie mit kill connection | query threadid beenden.

Leser, die an weiteren MySQL-bezogenen Inhalten interessiert sind, können sich die folgenden Themen auf dieser Site ansehen: „MySQL-Abfragekenntnisse“, „MySQL-Transaktionsoperationskenntnisse“, „MySQL-gespeicherte Prozedurkenntnisse“, „Zusammenfassung der Kenntnisse zu MySQL-Datenbanksperren“ und „Zusammenfassung der allgemeinen MySQL-Funktionen“.

Ich hoffe, dass dieser Artikel für jedermann beim Entwurf einer MySQL-Datenbank hilfreich ist.