Comment toutes les coroutines Swoole partagent-elles la même connexion à la base de données ?

Avec le développement rapide d'Internet et la croissance continue du volume de données, afin de garantir les hautes performances et l'évolutivité des applications, les développeurs ont commencé à utiliser largement les frameworks de programmation asynchrone. Depuis son lancement, Swoole est devenu un pionnier de la programmation asynchrone PHP et a été favorisé par de plus en plus de développeurs. Swoole fournit une prise en charge complète des coroutines, ce qui peut considérablement améliorer les capacités de traitement des demandes simultanées de l'application. Dans certains scénarios d'application, différentes coroutines doivent partager la même connexion à la base de données. Dans ce cas, la technologie de partage de coroutines Swoole doit être utilisée.

L'essence de la technologie de partage de coroutine Swoole est d'attribuer les connexions de base de données dans le pool de connexions à la coroutine pour utilisation. Une fois la coroutine utilisée, la connexion est renvoyée au pool de connexions. L'avantage de ceci est que cela peut éviter à chaque coroutine d'avoir à se connecter à la base de données, réduisant ainsi la surcharge de connexion et améliorant les performances des applications. Dans un environnement multi-coroutines, le partage des connexions aux bases de données dans le même pool de connexions peut également éviter d'être limité par le nombre de connexions.

Voyons comment Swoole implémente les coroutines pour partager la même connexion à la base de données.

Première étape : Installer l'extension Swoole

Le site officiel de Swoole fournit un didacticiel d'installation, qui ne nécessite que quelques étapes simples pour terminer l'installation. Une fois l'installation terminée, vous devez ajouter la configuration de l'extension swoole dans le fichier php.ini :

extension=swoole.so

Étape 2 : Créer un pool de connexion

Dans Swoole, la connexion Le pool est un concept très important, son rôle est d'augmenter la réutilisabilité des connexions aux bases de données. Le pool de connexion maintiendra la persistance de la connexion pour éviter les connexions fréquentes à la base de données et garantir l'efficacité de l'application. Nous pouvons utiliser la classe de pool de connexions de Swoole SwooleCoroutineMySQLPool pour créer un objet pool de connexions. SwooleCoroutineMySQLPool 来创建一个连接池对象。

<?php
$dbconfig = [
    'host' => '127.0.0.1',
    'port' => 3306,
    'user' => 'root',
    'password' => '',
    'database' => 'test_db',
    'charset' => 'utf8mb4',
    'timeout' => 30,
    'strict_type' => true,
    'fetch_mode' => true,
    'max_idle_time' => 3,
    'max_object_num' => 20,
];

$pool = new SwooleCoroutineMySQLPool($dbconfig);

连接池配置项说明：

• host：数据库连接的主机地址
• port：数据库连接的端口号
• user：数据库连接的用户名
• password：数据库连接的密码
• database：默认使用的数据库名称
• charset：连接使用的编码
• timeout：连接超时时间
• strict_type：是否开启严格模式
• fetch_mode：是否使用自定义数据获取方式
• max_idle_time：连接最大空闲时间
• max_object_num：连接池中最多存在的连接数

第三步：获取连接对象

创建连接池后，需要在每个协程中获取数据库连接对象。在Swoole中，可以通过 SwooleCoroutineMySQLPool->get() 方法获取数据库连接对象。

<?php
go(function () use ($pool) {
    // 获取连接对象
    $conn = $pool->get();
    // 查询操作
    $result = $conn->query('SELECT * FROM users');
    // 归还连接
    $pool->put($conn);
});

注意：每个协程都要通过连接池获取连接对象，避免多个协程同时操作同一个连接对象。

第四步：关闭连接

协程使用完连接对象后，应该将其归还给连接池。在Swoole中，可以通过 SwooleCoroutineMySQLPool->put() 将连接归还给连接池。

<?php
go(function () use ($pool) {
    $conn = $pool->get();
    $result = $conn->query('SELECT * FROM users');
    $pool->put($conn);
});

第五步：实现协程共享同一连接池

在实际的应用场景中，通常需要实现协程共享同一连接池的需求。这时候，我们可以通过依赖注入的方式来实现。

<?php
// 创建连接池
$dbconfig = [
    'host' => '127.0.0.1',
    'port' => 3306,
    'user' => 'root',
    'password' => '',
    'database' => 'test_db',
    'charset' => 'utf8mb4',
    'timeout' => 30,
    'strict_type' => true,
    'fetch_mode' => true,
    'max_idle_time' => 3,
    'max_object_num' => 20,
];

$pool = new SwooleCoroutineMySQLPool($dbconfig);

// 注册依赖库
$container = new Container();
$container->singleton(Pool::class, function () use ($pool) {
    return $pool;
});

在代码中注册了连接池实例到容器中，并使用 singleton() 方法将其设为单例对象，确保多个协程共享同一连接池的实例。

下面演示如何在协程中使用连接池：

<?php

// 协程1
go(function () use ($container) {
    $pool = $container->make(Pool::class);
    $conn = $pool->get();
    $result = $conn->query('SELECT * FROM users');
    $pool->put($conn);
});

// 协程2
go(function () use ($container) {
    $pool = $container->make(Pool::class);
    $conn = $pool->get();
    $result = $conn->query('SELECT * FROM users');
    $pool->put($conn);
});

通过 make()rrreee

Description de l'élément de configuration du pool de connexions :

• host : l'adresse hôte de la connexion à la base de données
• port : le numéro de port de la connexion à la base de données
• utilisateur : nom d'utilisateur pour la connexion à la base de données
• mot de passe : mot de passe pour la connexion à la base de données
• base de données : nom de base de données par défaut
• charset : encodage utilisé pour la connexion
• timeout : délai d'expiration de la connexion
• strict_type : s'il faut activer le mode strict
• fetch_mode : s'il faut utiliser la méthode d'acquisition de données personnalisée
• max_idle_time : Temps d'inactivité maximum de la connexion
• max_object_num : Le nombre maximum de connexions dans le pool de connexions

Étape 3 : Obtenir l'objet de connexion

# 🎜🎜#Créer une connexion Après le pooling, vous devez obtenir l'objet de connexion à la base de données dans chaque coroutine. Dans Swoole, vous pouvez obtenir l'objet de connexion à la base de données via la méthode SwooleCoroutineMySQLPool->get().

rrreee#🎜🎜#Remarque : Chaque coroutine doit obtenir l'objet de connexion via le pool de connexions pour éviter que plusieurs coroutines n'exploitent le même objet de connexion en même temps. #🎜🎜##🎜🎜#Étape 4 : Fermez la connexion #🎜🎜##🎜🎜#Une fois que la coroutine a fini d'utiliser l'objet de connexion, celui-ci doit être renvoyé au pool de connexion. Dans Swoole, la connexion peut être renvoyée au pool de connexions via SwooleCoroutineMySQLPool->put(). #🎜🎜#rrreee#🎜🎜#Étape 5 : Implémenter des coroutines partageant le même pool de connexions #🎜🎜##🎜🎜#Dans les scénarios d'application réels, il est généralement nécessaire d'implémenter l'exigence pour les coroutines de partager le même pool de connexions. À l’heure actuelle, nous pouvons y parvenir grâce à l’injection de dépendances. #🎜🎜#rrreee#🎜🎜#Enregistrez l'instance du pool de connexions dans le conteneur dans le code et utilisez la méthode singleton() pour la définir comme un objet singleton afin de garantir que plusieurs coroutines partagent la même connexion Une instance du pool. #🎜🎜##🎜🎜#Ce qui suit montre comment utiliser le pool de connexions dans la coroutine : #🎜🎜#rrreee#🎜🎜# Grâce à la méthode make(), vous pouvez obtenir des instances de bibliothèque dépendantes dans la coroutine, permettant ainsi à plusieurs coroutines de partager la même connexion à la base de données. #🎜🎜##🎜🎜#Summary#🎜🎜##🎜🎜#La technologie de partage de coroutines de Swoole peut éviter les connexions fréquentes aux bases de données et améliorer les performances et l'évolutivité des applications. En réalisant que les coroutines partagent le même pool de connexions, nous pouvons y parvenir grâce à l'injection de dépendances, de manière à atteindre l'objectif de plusieurs coroutines partageant la même connexion à la base de données. La prochaine fois que vous aurez besoin d'utiliser la technologie coroutine de Swoole lors du développement d'une application, vous pourriez aussi bien essayer la technologie de partage de coroutine pour améliorer l'efficacité de l'application. #🎜🎜#

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!