SqlConnection 的连接池机制解析
提供一篇关于sqlconnection连接池详细,有需要的朋友参考一下。
物理连接建立时,需要做和服务器握手,解析连接字符串,授权,约束的检查等等操作,而物理连接建立后,这些操作就不会去做了。这些操作是需要一定的时间的。所以很多人喜欢用一个静态对象存储 SqlConnection 来始终保持物理连接,但采用静态对象时,多线程访问会带来一些问题,实际上,我们完全不需要这么做,因为 SqlConnection 默认打开了连接池功能,当程序 执行 SqlConnection.Close 后,物理连接并不会被立即释放,所以这才出现当循环执行 Open操作时,执行时间几乎为0.
下面我们先看一下不打开连接池时,循环执行 SqlConnection.Open 的耗时
代码如下 | 复制代码 |
public static void OpenWithoutPooling() Stopwatch sw = new Stopwatch(); sw.Start(); sw.Stop(); sw.Reset(); sw.Start(); for (int i = 0; i
{ sw.Stop();
|
SqlConnection 默认是打开连接池的,如果要强制关闭,我们需要在连接字符串中加入 Pooling=False
调用程序如下:
代码如下 | 复制代码 |
Test.SqlConnectionTest.OpenWithoutPooling(); Console.WriteLine("Waiting for 10s"); System.Threading.Thread.Sleep(10 * 1000); Test.SqlConnectionTest.OpenWithoutPooling(); Console.WriteLine("Waiting for 600s"); System.Threading.Thread.Sleep(600 * 1000); Test.SqlConnectionTest.OpenWithoutPooling(); |
下面是测试结果
Without Pooling, first connection elapsed 13 ms
Without Pooling, average connection elapsed 5 ms
Wating for 10s
Without Pooling, first connection elapsed 6 ms
Without Pooling, average connection elapsed 4 ms
Wating for 600s
Without Pooling, first connection elapsed 7 ms
Without Pooling, average connection elapsed 4 ms
从这个测试结果看,关闭连接池后,平均每次连接大概要耗时4个毫秒左右,这个就是建立物理连接的平均耗时。
下面再看默认情况下的测试代码
代码如下 | 复制代码 |
public static void OpenWithPooling() sw.Start(); sw.Stop(); sw.Reset(); sw.Start(); for (int i = 0; i
{ sw.Stop();
Test.SqlConnectionTest.OpenWithPooling(); With Pooling, first connection elapsed 119 ms |
这个测试结果看,第一次耗时是119ms,这是因为我在测试代码中,首先运行的是这个测试过程,119 ms 是程序第一次启动时的首次连接耗时,这个耗时可能不光包括连接的时间,还有 ado.net 自己初始化的用时,所以这个用时可以不管。10秒以后在执行这个测试过程,首次执行的时间变成了0ms,这说明连接池机制发生了作用,SqlConnection Close 后,物理连接并没有被关闭,所以10秒后再执行,连接几乎没有用时间。
但我们发现一个有趣的现象,10分钟后,首次连接时间变成了6ms,这个和前面不打开连接池的测试用时几乎一样,也就是说10分钟后,物理连接被关闭了,又重新打开了一个物理连接。这个现象是因为连接池有个超时时间,默认情况下应该在5-10分钟之间,如果在此期间没有任何的连接操作,物理连接就会被关闭。那么我们有没有办法始终保持物理连接呢?方法是有的。
连接池设置中有一个最小连接池大小,默认为0,我们把它设置为大于0的值就可以保持若干物理连接始终不释放了。看代码
代码如下 | 复制代码 |
public static void OpenWithPooling(int minPoolSize) Stopwatch sw = new Stopwatch(); sw.Start(); sw.Stop(); sw.Reset(); sw.Start(); for (int i = 0; i
{ sw.Stop(); |
其实只要在连接字符串中加入一个 Min Pool Size=n 就可以了。
调用代码
代码如下 | 复制代码 |
Test.SqlConnectionTest.OpenWithPooling(1); With Pooling Min Pool Size=1, first connection elapsed 5 ms |
我们可以看到当 Min Pool Size = 1 时,除了首次连接用时5ms以外,即便过了10分钟,用时还是0ms,物理连接没有被关闭。

Outils d'IA chauds

Undresser.AI Undress
Application basée sur l'IA pour créer des photos de nu réalistes

AI Clothes Remover
Outil d'IA en ligne pour supprimer les vêtements des photos.

Undress AI Tool
Images de déshabillage gratuites

Clothoff.io
Dissolvant de vêtements AI

AI Hentai Generator
Générez AI Hentai gratuitement.

Article chaud

Outils chauds

Bloc-notes++7.3.1
Éditeur de code facile à utiliser et gratuit

SublimeText3 version chinoise
Version chinoise, très simple à utiliser

Envoyer Studio 13.0.1
Puissant environnement de développement intégré PHP

Dreamweaver CS6
Outils de développement Web visuel

SublimeText3 version Mac
Logiciel d'édition de code au niveau de Dieu (SublimeText3)

Présentation de l'utilisation du pool de connexions php-fpm pour améliorer les performances d'accès aux bases de données : Dans le développement Web, l'accès aux bases de données est l'une des opérations les plus fréquentes et les plus longues. La méthode traditionnelle consiste à créer une nouvelle connexion à la base de données pour chaque opération de base de données, puis à fermer la connexion après utilisation. Cette méthode entraînera l’établissement et la fermeture fréquents de connexions à la base de données, augmentant ainsi la surcharge du système. Afin de résoudre ce problème, vous pouvez utiliser la technologie de pool de connexions php-fpm pour améliorer les performances d'accès à la base de données. Principe du pool de connexions : Le pool de connexions est une technologie de mise en cache qui regroupe un certain nombre de bases de données

Comment fermer correctement le pool de connexions MySQL dans un programme Python ? Lors de l’écriture de programmes en Python, nous devons souvent interagir avec des bases de données. La base de données MySQL est une base de données relationnelle largement utilisée. En Python, nous pouvons utiliser la bibliothèque tierce pymysql pour connecter et faire fonctionner la base de données MySQL. Lorsque nous écrivons du code lié à la base de données, une question très importante est de savoir comment fermer correctement la connexion à la base de données, en particulier lors de l'utilisation d'un pool de connexions. Le pooling de connexions est une gestion

Comment résoudre le problème des fuites de connexion réseau dans le développement Java. Avec le développement rapide des technologies de l'information, la connexion réseau devient de plus en plus importante dans le développement Java. Cependant, le problème des fuites de connexion réseau dans le développement Java est progressivement devenu important. Les fuites de connexion réseau peuvent entraîner une dégradation des performances du système, un gaspillage de ressources, des pannes du système, etc. Par conséquent, résoudre le problème des fuites de connexion réseau est devenu crucial. Une fuite de connexion réseau signifie que la connexion réseau n'est pas fermée correctement dans le développement Java, ce qui entraîne l'échec de la libération des ressources de connexion, empêchant ainsi le bon fonctionnement du système. réseau de solutions

La configuration d'un pool de connexions MySQL à l'aide de PHP peut améliorer les performances et l'évolutivité. Les étapes comprennent : 1. Installer l'extension MySQLi ; 2. Créer une classe de pool de connexions ; 3. Définir la configuration du pool de connexions ; 4. Créer une instance de pool de connexions ; Grâce au regroupement de connexions, les applications peuvent améliorer les performances en évitant de créer une nouvelle connexion à la base de données pour chaque requête.

Comment utiliser et optimiser correctement le pool de connexions MySQL dans les programmes ASP.NET ? Introduction : MySQL est un système de gestion de bases de données largement utilisé qui offre des performances élevées, une fiabilité et une facilité d'utilisation. Dans le développement ASP.NET, l'utilisation d'une base de données MySQL pour le stockage des données est une exigence courante. Afin d'améliorer l'efficacité et les performances des connexions aux bases de données, nous devons utiliser et optimiser correctement le pool de connexions MySQL. Cet article explique comment utiliser et optimiser correctement le pool de connexions MySQL dans les programmes ASP.NET.

Comment utiliser correctement le pool de connexions MySQL dans le programme Node.js pour optimiser les performances ? Avec le développement continu des applications Internet, les bases de données sont devenues le cœur de la plupart des applications. Dans Node.js, MySQL est l'une des bases de données relationnelles les plus couramment utilisées. Cependant, dans des situations de concurrence élevée, l'utilisation directe des connexions MySQL entraînera une dégradation des performances. Pour résoudre ce problème, nous pouvons utiliser le pool de connexions MySQL pour optimiser les performances. Un pool de connexions est une collection d’objets de connexion établis. Grâce au pool de connexions, l'application

Comment utiliser et gérer correctement les performances des transactions du pool de connexions MySQL dans le programme Node.js ? Introduction : Avec le développement continu de la technologie Internet, Node.js est devenu un langage de développement côté serveur très populaire. Dans de nombreuses applications Web, les performances transactionnelles de la base de données jouent un rôle crucial dans la stabilité et la haute fiabilité du système. MySQL est un système de gestion de bases de données relationnelles open source largement utilisé dans les programmes Node.js. Cet article se concentrera sur la façon de correctement

Le framework Gin est un framework Web léger conçu pour fournir un modèle de traitement Web hautes performances et haute disponibilité. Dans le framework Gin, le client HTTP et le pool de connexions sont des composants très importants. Cet article approfondira les détails d'implémentation sous-jacents du client HTTP et du pool de connexions dans le framework Gin. 1. Client HTTP Le client HTTP est le composant principal du framework Gin pour l'envoi de requêtes HTTP. Dans le framework Gin, il existe de nombreuses façons différentes d'implémenter des clients HTTP, mais les deux méthodes les plus couramment utilisées sont
