Ein Artikel, der ausführlich erklärt, wie man die leistungsstarke sql.DB in Go konfiguriert

Dieser Artikel wird in der Tutorial-Kolumne von golang vorgestellt, um die Konfiguration von Hochleistungs-SQL.DB in Go vorzustellen. Ich hoffe, dass er Freunden in Not hilfreich sein wird!

Es gibt viele Tutorials zum Go-Typ sql.DB und wie man ihn zum Durchführen von SQL-Datenbankabfragen verwendet. Das meiste davon deckt jedoch nicht die Methoden SetMaxOpenConns(), SetMaxIdleConns() und SetConnMaxLifetime() ab, die Sie zum Konfigurieren von sql.DBs Verhalten und ändern Sie seine Leistung. sql.DB类型和如何使用它来执行SQL数据库查询的。但大多数内容都没有讲述SetMaxOpenConns(), SetMaxIdleConns() 和 SetConnMaxLifetime()方法， 您可以使用它们来配置sql.DB的行为并改变其性能。

在本文我将详细解释这些设置的作用，并说明它们所能产生的(积极和消极)影响。

开放和空闲连接
一个sql.DB对象就是一个数据库连接池，它包含“正在用”和“空闲的”连接。一个正在用的连接指的是，你正用它来执行数据库任务，例如执行SQL语句或行查询。当任务完成连接就是空闲的。

当您创建sql.DB执行数据库任务时，它将首先检查连接池中是否有可用的空闲连接。如果有可用的连接，那么Go将重用现有连接，并在执行任务期间将其标记为正在使用。如果池中没有空闲连接，而您需要一个空闲连接，那么Go将创建一个新的连接。

SetMaxOpenConns方法

默认情况下，在同一时间打开连接的数量是没有限制(包含使用中+空闲)。但你可以通过SetMaxOpenConns()方法实现自定义限制，如下所示:

// 初始化一个新的连接池
db, err := sql.Open("postgres", "postgres://user:pass@localhost/db")
if err != nil {
    log.Fatal(err)
}

// 设置当前最大开放连接数（包括空闲和正在使用的）为5。
// 如果设置为0代表连接数没有限制，默认是没有限制数量的。
db.SetMaxOpenConns(5)

在这个示例代码中，连接池现在有5个并发打开的连接数。如果所有5个连接都已经被标记为正在使用，并且需要另一个新的连接，那么应用程序将被迫等待，直到5个连接中的一个被释放并变为空闲。

为了说明更改MaxOpenConns的影响，我运行了一个基准测试，将最大打开连接数设置为1、2、5、10和无限。基准测试在PostgreSQL数据库上执行并行的INSERT语句，您可以在这里找到代码。测试结果:

BenchmarkMaxOpenConns1-8                 500       3129633 ns/op         478 B/op         10 allocs/op
BenchmarkMaxOpenConns2-8                1000       2181641 ns/op         470 B/op         10 allocs/op
BenchmarkMaxOpenConns5-8                2000        859654 ns/op         493 B/op         10 allocs/op
BenchmarkMaxOpenConns10-8               2000        545394 ns/op         510 B/op         10 allocs/op
BenchmarkMaxOpenConnsUnlimited-8        2000        531030 ns/op         479 B/op          9 allocs/op
PASS

对于这个基准测试，我们可以看到，允许打开的连接越多，在数据库上执行INSERT操作所花费的时间就越少(打开的连接数为1时，执行速度3129633ns/op，而无限连接：531030ns/op——大约快了6倍)。这是因为允许打开的连接越多，可以并发执行的数据库查询就越多。

SetMaxIdleConns方法
默认情况下，sql.DB允许连接池中最多保留2个空闲连接。你可以通过SetMaxIdleConns()

In diesem Artikel werde ich ausführlich erklären, was diese Einstellungen bewirken und welche (positiven und negativen) Auswirkungen sie haben können.

Offene und inaktive Verbindungen

Ein sql.DB-Objekt ist ein Datenbankverbindungspool, der „verwendete“ und „inaktive“ Verbindungen enthält. Eine aktive Verbindung bedeutet, dass Sie sie zum Ausführen von Datenbankaufgaben verwenden, beispielsweise zum Ausführen von SQL-Anweisungen oder Zeilenabfragen. Nach Abschluss der Aufgabe ist die Verbindung frei.

Wenn Sie sql.DB erstellen, um Datenbankaufgaben auszuführen, prüft es zunächst, ob im Verbindungspool freie Verbindungen verfügbar sind. Wenn eine Verbindung verfügbar ist, verwendet Go die vorhandene Verbindung wieder und markiert sie während der Ausführung der Aufgabe als verwendet. Wenn im Pool keine freie Verbindung vorhanden ist und Sie eine benötigen, erstellt Go eine neue.


SetMaxOpenConns-Methode

🎜Standardmäßig ist die Anzahl der gleichzeitig geöffneten Verbindungen unbegrenzt (einschließlich in Verwendung + Leerlauf). Sie können jedoch benutzerdefinierte Grenzwerte über die Methode SetMaxOpenConns() implementieren, wie unten gezeigt: 🎜

//  初始化一个新的连接池
db, err := sql.Open("postgres", "postgres://user:pass@localhost/db")
if err != nil {
    log.Fatal(err)
}

// 设置最大空闲连接数为5。 将此值设置为小于或等于0将意味着不保留空闲连接。
db.SetMaxIdleConns(5)

🎜 In diesem Beispielcode verfügt der Verbindungspool jetzt über 5 gleichzeitig offene Verbindungen. Wenn alle 5 Verbindungen bereits als verwendet markiert sind und eine weitere neue Verbindung erforderlich ist, muss die Anwendung warten, bis eine der 5 Verbindungen freigegeben und frei wird. 🎜🎜Um die Auswirkungen der Änderung von MaxOpenConns zu veranschaulichen, habe ich einen Benchmark durchgeführt, bei dem die maximale Anzahl offener Verbindungen auf 1, 2, 5, 10 und unendlich festgelegt wurde. Der Benchmark führt parallele INSERT-Anweisungen auf einer PostgreSQL-Datenbank aus, den Code finden Sie hier. Testergebnisse: 🎜🎜🎜BenchmarkMaxOpenConns1-8 500 3129633 ns/op 478 B/op 10 Zuweisungen/op🎜BenchmarkMaxOpenConns2-8 1000 2181641 ns/op 470 B/op 10. Zuweisungen/op🎜BenchmarkMaxOpenConns5-8 2000 859654 ns/op 493 B /op 10 Zuweisungen/op🎜BenchmarkMaxOpenConns10-8 2000 545394 ns/op 510 B/op 10 Zuweisungen/op🎜BenchmarkMaxOpenConnsUnlimited-8 2000 531030 ns/op 479 B/op 9 Zuweisungen/op🎜PASS🎜

🎜dafür Beim Benchmark-Test können wir sehen, dass die Ausführung des INSERT-Vorgangs in der Datenbank umso weniger Zeit in Anspruch nimmt, je mehr offene Verbindungen zulässig sind (wenn die Anzahl der offenen Verbindungen 1 beträgt, beträgt die Ausführungsgeschwindigkeit 3129633 ns/). op, Und unbegrenzte Verbindung: 531030ns/op – etwa 6-mal schneller). Denn je mehr Verbindungen Sie zulassen, desto mehr Datenbankabfragen können gleichzeitig ausgeführt werden. 🎜🎜🎜SetMaxIdleConns-Methode🎜🎜Standardmäßig lässt sql.DB zu, dass bis zu 2 inaktive Verbindungen im Verbindungspool gehalten werden. Sie können es über die Methode SetMaxIdleConns() ändern, wie unten gezeigt: 🎜

// 初始化一个新的连接池
db, err := sql.Open("postgres", "postgres://user:pass@localhost/db")
if err != nil {
    log.Fatal(err)
}

// 将连接的最大生存期设置为1小时。将其设置为0意味着没有最大生存期，连接将永远可重用(这是默认行为)
db.SetConnMaxLifetime(time.Hour)

🎜 Theoretisch verbessert das Zulassen von mehr Leerlaufverbindungen im Pool die Leistung, da die Wahrscheinlichkeit geringer ist, dass bei Null begonnen wird neue Verbindungen - und trägt so zur Verbesserung der Datenbankleistung bei. 🎜🎜Sehen wir uns den gleichen Benchmark an, wobei die maximale Leerlaufverbindung auf „Keine“, 1, 2, 5 und 10 eingestellt ist: 🎜🎜🎜BenchmarkMaxIdleConnsNone-8 300 4567245 ns/op 58174 B/op 625 allocs/op 🎜BenchmarkMaxIdleConns1-8. 20 00 568765 ns/op 2596 B/op 32 Zuweisungen/op🎜BenchmarkMaxIdleConns2-8 2000 529359 ns/op 596 B/op 11 Zuweisungen/op🎜BenchmarkMaxIdleConns5-8 2000 506207 ns/op 451 B/op 9 Zuweisungen/ op🎜BenchmarkMaxIdleConns10- 8 2000 501639 ns/op 450 B/op 9 Zuweisungen/op🎜PASS🎜

当MaxIdleConns设置为none时，必须为每个INSERT从头创建一个新的连接，我们可以从基准测试中看到，平均运行时和内存使用量相对较高。

只允许保留和重用一个空闲连接对基准测试影响特别明显——它将平均运行时间减少了大约8倍，内存使用量减少了大约20倍。继续增加空闲连接池的大小会使性能变得更好，尽管改进并不明显。

那么，您应该维护一个大的空闲连接池吗?答案取决于应用程序。重要的是要意识到保持空闲连接是有代价的—它占用了可以用于应用程序和数据库的内存。

还有一种可能是，如果一个连接空闲时间太长，那么它可能会变得不可用。例如，MySQL的wait_timeout设置将自动关闭任何8小时(默认)内未使用的连接。

当发生这种情况时，sql.DB会优雅地处理它。坏连接将自动重试两次，然后放弃，此时Go将该连接从连接池中删除，并创建一个新的连接。因此，将MaxIdleConns设置得太大可能会导致连接变得不可用，与空闲连接池更小(使用更频繁的连接更少)相比，会占有更多的资源。所以，如果你很可能很快就会再次使用，你只需保持一个空闲的连接。

最后要指出的是，MaxIdleConns应该总是小于或等于MaxOpenConns.
。Go强制执行此操作，并在必要时自动减少MaxIdleConns。

SetConnMaxLifetime方法
现在让我们看看SetConnMaxLifetime()方法，它设置连接可重用的最大时间长度。如果您的SQL数据库也实现了最大连接生命周期，或者—例如—您希望方便地在负载均衡器后交换数据库，那么这将非常有用。
你可以这样使用它:

// 初始化一个新的连接池
db, err := sql.Open("postgres", "postgres://user:pass@localhost/db")
if err != nil {
    log.Fatal(err)
}

// 将连接的最大生存期设置为1小时。将其设置为0意味着没有最大生存期，连接将永远可重用(这是默认行为)
db.SetConnMaxLifetime(time.Hour)

在这个例子中，所有的连接都将在创建后1小时“过期”，并且在过期后无法重用。但注意:

• 这并不能保证连接将在池中存在整整一个小时；很有可能，由于某些原因，连接变得不可用，并在此之前自动关闭。
• 一个连接在创建后一个多小时仍然可以被使用——它只是在这个时间之后不能被重用。
• 这不是空闲超时。连接将在第一次创建后1小时过期——而不是在最后一次空闲后1小时。
• 每隔一秒自动运行一次清理操作，从连接池中删除“过期”的连接。

从理论上讲，ConnMaxLifetime越短，连接过期的频率就越高——因此，需要从头创建连接的频率就越高。为了说明这一点，我运行了将ConnMaxLifetime设置为100ms、200ms、500ms、1000ms和无限(永远重用)的基准测试，默认设置为无限打开连接和2个空闲连接。

这些时间段显然比您在大多数应用程序中使用的时间要短得多，但它们有助于很好地说明行为。

BenchmarkConnMaxLifetime100-8               2000        637902 ns/op        2770 B/op         34 allocs/op
BenchmarkConnMaxLifetime200-8               2000        576053 ns/op        1612 B/op         21 allocs/op
BenchmarkConnMaxLifetime500-8               2000        558297 ns/op         913 B/op         14 allocs/op
BenchmarkConnMaxLifetime1000-8              2000        543601 ns/op         740 B/op         12 allocs/op
BenchmarkConnMaxLifetimeUnlimited-8         3000        532789 ns/op         412 B/op          9 allocs/op
PASS

在这些特定的基准测试中，我们可以看到，与无限生存期相比，在100ms生存期时内存使用量增加了3倍以上，而且每个INSERT的平均运行时也稍微长一些。

如果您在代码中设置了ConnMaxLifetime，那么一定要记住连接将过期(随后重新创建)的频率。例如，如果您总共有100个连接，而ConnMaxLifetime为1分钟，那么您的应用程序可能每秒钟杀死和重新创建1.67个连接(平均值)。您不希望这个频率太大，最终会阻碍性能，而不是提高性能。

连接数量超出
最后，如果不说明超过数据库连接数量的硬限制将会发生什么，那么本文就不完整了。 为了说明这一点，我将修改postgresql.conf文件，这样总共只允许5个连接(默认是100个)…

max_connections = 5

然后在无限连接的情况下重新运行基准测试……

BenchmarkMaxOpenConnsUnlimited-8    — FAIL: BenchmarkMaxOpenConnsUnlimited-8
   main_test.go: 14: pq: sorry, too many clients already
   main_test.go: 14: pq: sorry, too many clients already
   main_test.go: 14: pq: sorry, too many clients already
FAIL

一旦达到5个连接的硬限制，数据库驱动程序(pq)立即返回一个太多客户端连接的错误消息，而无法完成INSERT。为了防止这个错误，我们需要将sql.DB中打开连接的最大总数(正在使用的+空闲的)设置为低于5。像这样:

// 初始化一个新的连接池
db, err := sql.Open("postgres", "postgres://user:pass@localhost/db")
if err != nil {
    log.Fatal(err)}
    // 将打开的连接数(正在使用的连接+空闲的连接)设置为最大总数3。
 db.SetMaxOpenConns (3)

现在，sql.DB在任何时候最多只能创建3个连接，基准测试运行时应该不会出现任何错误。但是这样做需要注意：当达到开放连接数限制，并且所有连接都在使用时，应用程序需要执行的任何新的数据库任务都将被迫等待，直到连接标记为空闲。例如，在web应用程序的上下文中，用户的HTTP请求看起来会“挂起”，甚至在等待数据库任务运行时可能会超时。

为了减轻这种情况，你应该始终在一个上下文中传递。在调用数据库时，启用上下文的方法(如ExecContext())，使用固定的、快速的超时上下文对象。

 
总结
1、根据经验，应该显式设置MaxOpenConns值。这应该小于数据库和基础设施对连接数量的硬性限制。
2、一般来说，更高的MaxOpenConns和MaxIdleConns值将带来更好的性能。但你应该注意到效果是递减的，连接池空闲连接太多(连接没有被重用，最终会变坏)实际上会导致性能下降。
3、为了降低上面第2点带来的风险，您可能需要设置一个相对较短的ConnMaxLifetime。但你也不希望它太短，导致连接被杀死或不必要地频繁重建。
4、MaxIdleConns应该总是小于或等于MaxOpenConns。
对于中小型web应用程序，我通常使用以下设置作为起点，然后根据实际吞吐量水平的负载测试结果进行优化。

db.SetMaxOpenConns(25)db.SetMaxIdleConns(25)db.SetConnMaxLifetime(5*time.Minute)

到此这篇关于golang配制高性能sql.DB的使用的文章就介绍到这了                                                     

Das obige ist der detaillierte Inhalt vonEin Artikel, der ausführlich erklärt, wie man die leistungsstarke sql.DB in Go konfiguriert. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!