So legen Sie die maximale Anzahl von Verbindungen und die maximale Anzahl von Leerlaufverbindungen in Golang in Kombination mit MySQL fest

Die maximale Anzahl von Verbindungen und die maximale Anzahl von Leerlaufverbindungen werden in Datenbank/SQL in der Golang-Standardbibliothek definiert.

Das SQL-Treiberpaket, das im Beispiel in diesem Artikel zum Herstellen einer Verbindung mit MySQL verwendet wird, ist github.com/go-sql-driver/mysql

Die Schnittstelle zum Festlegen der maximalen Anzahl von Verbindungen ist

func (db *DB) SetMaxOpenConns(n int)

Legen Sie die maximale Anzahl fest Verbindungen, die geöffnet werden können, um eine Verbindung zu MySQL herzustellen.

Wenn n

Der Standardwert ist 0, was bedeutet, dass die Anzahl der Verbindungen unbegrenzt ist.

Ein weiterer Parameter, der sich auf die Anzahl der Verbindungen bezieht, ist MaxIdleConns, der die maximale Anzahl inaktiver Verbindungen darstellt.

Wenn MaxIdleConns größer als 0 und größer als MaxOpenConns ist, wird MaxIdleConns auf den Wert MaxOpenConns angepasst. Wenn überschüssige Verbindungen vorhanden sind, werden die überschüssigen Verbindungen geschlossen.

Die Schnittstelle zum Festlegen der maximalen Anzahl inaktiver Verbindungen lautet:

func (db *DB) SetMaxIdleConns(n int)

Wenn n

Die standardmäßige maximale Anzahl inaktiver Verbindungen beträgt 2:
const defaultMaxIdleConns = 2

Bezüglich der Beziehung zwischen offenen Verbindungen und inaktiven Verbindungen fügen Sie hinzu:

Geöffnete Verbindungen = verwendete Verbindungen (in Verwendung) + inaktive Verbindungen (inaktiv)

Lassen Sie uns die maximale Anzahl an Verbindungen und die maximale Anzahl an Leerlaufverbindungen testen und überprüfen.

1. Test der maximalen Anzahl von Verbindungen

Setzen Sie zunächst die maximale Anzahl offener Verbindungen auf 1, öffnen Sie dann 20 Goroutinen, jede Goroutine führt die SQL-Anweisung aus und gibt die Verbindungs-ID der Verbindung aus, die zum Ausführen der SQL verwendet wird. Beobachten Sie die Ausführung anderer Goroutinen, die SQL ausführen müssen, wenn Sie zeitaufwändige SQL-Anweisungen ausführen, die Verbindungen belegen.

Der Beispielcode lautet wie folgt:

package main

import (
        "database/sql"
        "log"

        _ "github.com/go-sql-driver/mysql"
)

var DB *sql.DB
var dataBase = "root:Aa123456@tcp(127.0.0.1:3306)/?loc=Local&parseTime=true"

func Init() {
        var err error
        DB, err = sql.Open("mysql", dataBase)
        if err != nil {
                log.Fatalln("open db fail:", err)
        }

        DB.SetMaxOpenConns(1)

        err = DB.Ping()
        if err != nil {
                log.Fatalln("ping db fail:", err)
        }
}

func main() {
        Init()
        
        //开启20个goroutine
        for i:=0; i < 20; i++ {
                go one_worker(i)
        }
        
        select {
        }

}

func one_worker(i int) {
        var connection_id int
        err := DB.QueryRow("select CONNECTION_ID()").Scan(&connection_id)
        if err != nil {
                log.Println("query connection id failed:", err)
                return
        }

        log.Println("worker:", i, ", connection id:", connection_id)

        var result int
        err = DB.QueryRow("select sleep(10)").Scan(&result)
        if err != nil {
                log.Println("query sleep connection id faild:", err)
                return
        }

}

Ausgabe

2019/10/02 18:14:25 Arbeiter: 2, Verbindungs-ID: 55
2019/10/02 18:14:25 Arbeiter: 17, Verbindung ID: 55
2019/10/02 18:14:25 Arbeiter: 11, Verbindungs-ID: 55
2019/10/02 18:14:35 Arbeiter: 3, Verbindungs-ID: 55
2019/10/02 18:14 :45 Arbeiter: 0, Verbindungs-ID: 55
2019/10/02 18:14:45 Arbeiter: 4, Verbindungs-ID: 55
2019/10/02 18:14:45 Arbeiter: 5, Verbindungs-ID: 55
2019 /10/ 02 18:15:05 Arbeiter: 7 , Verbindungs-ID: 55
2019/10/02 18:15:25 Arbeiter: 15 , Verbindungs-ID: 55
2019/10/02 18:15:25 Arbeiter: 6 , Verbindungs-ID: 55
2019/10/02 18:15:35 Arbeiter: 13 , Verbindungs-ID: 55
2019/10/02 18:15:45 Arbeiter: 19 , Verbindungs-ID: 55
2019/10/02 18 :15: 45 Arbeiter: 10 , Verbindungs-ID: 55
2019/10/02 18:15:45 Arbeiter: 12 , Verbindungs-ID: 55
2019/10/02 18:15:55 Arbeiter: 14 , Verbindungs-ID: 55
02.10.2019 18:16:15 Arbeiter: 8, Verbindungs-ID: 55
02.10.2019 18:16:35 Arbeiter: 18, Verbindungs-ID: 55
02.10.2019 18:16:35 Arbeiter : 1, Verbindungs-ID: 55
02.10.2019 18:17:05 Arbeiter: 16, Verbindungs-ID: 55
02.10.2019 18:17:35 Arbeiter: 9, Verbindungs-ID: 55

Verwenden Sie Show Prozessliste, um die Verbindung anzuzeigen

mysql> show processlist;
+----+------+-----------------+------+---------+------+------------+------------------+
| Id | User | Host            | db   | Command | Time | State      | Info             |
+----+------+-----------------+------+---------+------+------------+------------------+
| 20 | root | localhost       | NULL | Query   |    0 | starting   | show processlist |
| 55 | root | localhost:59518 | NULL | Query   |    5 | User sleep | select sleep(10) |
+----+------+-----------------+------+---------+------+------------+------------------+
2 rows in set (0.00 sec)

Verwenden Sie netstat, um die Verbindung anzuzeigen

netstat -an | grep 3306
tcp4       0      0  127.0.0.1.3306         127.0.0.1.59518        ESTABLISHED
tcp4       0      0  127.0.0.1.59518        127.0.0.1.3306         ESTABLISHED
tcp46      0      0  *.3306                 *.*                    LISTEN

Wie Sie den Ergebnissen entnehmen können, verwenden 20 Goroutinen abwechselnd dieselbe Verbindung (Verbindungs-ID ist 55), um SQL-Anweisungen auszuführen.

Andere Goroutinen wechseln in den Blockierungszustand, wenn die Verbindung belegt ist. Keine andere Goroutine kann die Verbindung nutzen, bis die Verbindung aufgebraucht ist.

Auch wenn mehrere Goroutinen SQL ausführen, werden nicht mehrere Verbindungen erstellt.

Daher wird die Einstellung für die maximale Anzahl von Verbindungen wirksam.

Einige Leser fragen sich vielleicht: Wie hoch ist derzeit die maximale Anzahl freier Verbindungen, wenn sie die festgelegte maximale Anzahl von Leerlaufverbindungen nicht gesehen haben?

Wie bereits erwähnt, beträgt die standardmäßige maximale Anzahl von Leerlaufverbindungen 2.

Testen wir die maximale Anzahl von Space-Verbindungen.

2. Test der maximalen Anzahl inaktiver Verbindungen

Setzen Sie im folgenden Beispiel die maximale Anzahl von Verbindungen auf 1 und die maximale Anzahl inaktiver Verbindungen auf 0.

Und führen Sie alle 3 Sekunden eine SQL-Anweisung aus.

Der Code lautet wie folgt:

package main

import (
        "database/sql"
        "log"
        "time"

        _ "github.com/go-sql-driver/mysql"

)

var DB *sql.DB
var dataBase = "root:Aa123456@tcp(127.0.0.1:3306)/?loc=Local&parseTime=true"

func mysqlInit() {
        var err error
        DB, err = sql.Open("mysql", dataBase)
        if err != nil {
                log.Fatalln("open db fail:", err)
        }

        DB.SetMaxOpenConns(1)
        DB.SetMaxIdleConns(0)

        err = DB.Ping()
        if err != nil {
                log.Fatalln("ping db fail:", err)
        }
}

func main() {
        mysqlInit()

        for {
                execSql()
                time.Sleep(3*time.Second)
        }
}


func execSql() {
        var connection_id int
        err := DB.QueryRow("select CONNECTION_ID()").Scan(&connection_id)
        if err != nil {
                log.Println("query connection id failed:", err)
                return
        }

        log.Println("connection id:", connection_id)
}

Ausgabe:

13.10.2019 23:06:00 Verbindungs-ID: 26
13.10.2019 23:06:03 Verbindungs-ID: 27
10.10.2019 13 23: 06:06 Verbindungs-ID: 28
13.10.2019 23:06:09 Verbindungs-ID: 29
13.10.2019 23:06:12 Verbindungs-ID: 30
13.10.2019 23:06: 15 Verbindungs-ID: 31
13.10.2019 23:06:18 Verbindungs-ID: 32
13.10.2019 23:06:21 Verbindungs-ID: 33
13.10.2019 23:06:24 Verbindungs-ID: 34
13.10.2019 23:06:27 Verbindungs-ID: 35
13.10.2019 23:06:30 Verbindungs-ID: 36
13.10.2019 23:06:33 Verbindungs-ID: 37
10.10.2019 13 23: 06:36 Verbindungs-ID: 38

Wie Sie den Ergebnissen entnehmen können, ist die zur Ausführung von SQL verwendete Verbindungs-ID jedes Mal anders.

Setzen Sie die maximale Anzahl inaktiver Verbindungen auf 0. Nach jeder SQL-Ausführung wird die Verbindung nicht in den inaktiven Verbindungspool gestellt, sondern geschlossen. Bei der nächsten SQL-Ausführung wird eine neue Verbindung wiederhergestellt .

Das obige ist der detaillierte Inhalt vonSo legen Sie die maximale Anzahl von Verbindungen und die maximale Anzahl von Leerlaufverbindungen in Golang in Kombination mit MySQL fest. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!