Pratique de programmation asynchrone Swoole : créer un système de file d'attente hautes performances

Avec le développement rapide des applications Internet, de plus en plus d'entreprises commencent à utiliser la programmation asynchrone pour améliorer les performances du code et l'efficacité des applications. Swoole est un puissant framework de programmation asynchrone pour PHP, avec des performances élevées, une concurrence élevée et une excellente évolutivité. Dans cet article, nous présenterons comment utiliser Swoole pour créer un système de file d'attente hautes performances.

Tout d’abord, nous devons comprendre ce qu’est un système de file d’attente. Le système de file d'attente est un système de planification global de services qui améliore la vitesse de réponse des services et les capacités de traitement simultané du système grâce à la gestion des files d'attente et à la planification de divers services. Dans les applications pratiques, les systèmes de files d'attente sont généralement utilisés pour mettre en œuvre des fonctions telles qu'un accès simultané élevé, la planification de tâches asynchrones, l'équilibrage de charge, etc. Par conséquent, leurs hautes performances et leur haute disponibilité sont nécessaires.

Ensuite, nous utiliserons les exigences suivantes comme exemple pour expliquer comment utiliser Swoole pour créer un système de file d'attente hautes performances :

1. prend en charge plusieurs files d'attente et peut gérer les files d'attente
2. prend en charge l'ajout et l'exécution de tâches, et ; peut gérer l'état des tâches ;
3. prend en charge plusieurs consommateurs pour traiter les tâches et gérer les consommateurs ;
4. prend en charge les nouvelles tentatives de tâches et le traitement des délais d'attente ;
5. prend en charge le traitement asynchrone et le traitement synchrone des tâches.

Maintenant, passons aux choses sérieuses et commençons à utiliser Swoole pour créer ce système de file d'attente haute performance.

1. Présentation de Swoole

Tout d'abord, nous devons introduire Swoole dans le projet. Ici, nous pouvons facilement introduire les dépendances Swoole via Composer.

composer require swoole/swoole

2. Construire la file d'attente

Dans le système de file d'attente, la file d'attente est la structure de base pour stocker les tâches. Nous devons créer une file d'attente et ajouter des tâches à la file d'attente. Ici, nous utilisons Redis comme méthode de stockage de file d'attente et utilisons l'extension PHP Redis pour faire fonctionner la file d'attente.

1. Créer une connexion Redis

Avant d'utiliser Redis, nous devons d'abord créer une connexion à Redis. Ici, nous créons un pool de connexions Redis pour gérer les connexions Redis.

utilisez SwooleCoroutineChannel;

class RedisPool
{

private $max;
private $pool;

public function __construct($max = 100)
{
    $this->max = $max;
    $this->pool = new Channel($max);
}

public function get($config)
{
    if (!$this->pool->isEmpty()) {
        return $this->pool->pop();
    }

    $redis = new Redis();
    $redis->connect($config['host'], $config['port']);
    $redis->select($config['db']);
    
    return $redis;
}

public function put($redis)
{
    if ($this->pool->length() < $this->max) {
        $this->pool->push($redis);
    } else {
        $redis->close();
    }
}

}

2. Créer une file d'attente

Ensuite, nous pouvons créer une classe de file d'attente pour gérer les opérations de file d'attente, y compris les opérations d'ajout de tâches, d'acquisition de tâches et de suppression de tâches.

file d'attente de classe
{

private $redis;

public function __construct($config)
{
    $this->redis = (new RedisPool())->get($config);
}

public function push($queueName, $data)
{
    $this->redis->lpush($queueName, $data);
}

public function pop($queueName)
{
    return $this->redis->rpop($queueName);
}

public function del($queueName, $data)
{
    $this->redis->lrem($queueName, -1, $data);
}

}

3. Implémenter l'exécution des tâches

Après avoir ajouté des tâches à la file d'attente, nous avons besoin d'un exécuteur de tâches pour exécuter les tâches. Ici, nous utilisons des coroutines pour implémenter l'exécution asynchrone des tâches et utilisons les processus Worker pour améliorer l'efficacité de l'exécution des tâches.

1. Créer un processus Worker

Dans Swoole, nous pouvons utiliser le processus Worker pour implémenter des tâches de traitement multi-processus. Ici, nous créons un processus Worker pour gérer la tâche.

$worker = new SwooleProcessWorker();

2. Créer un exécuteur de coroutine

Ensuite, nous pouvons créer un exécuteur de coroutine pour gérer les tâches. Ici, nous utilisons des coroutines pour implémenter l'exécution de tâches asynchrones et utilisons des pools de coroutines de style Golang pour améliorer l'efficacité du traitement simultané.

class CoroutineExecutor
{

private $pool;
private $redisConfig;

public function __construct($maxCoroutineNum, $redisConfig)
{
    $this->pool = new SwooleCoroutineChannel($maxCoroutineNum);
    $this->redisConfig = $redisConfig;

    for ($i = 0; $i < $maxCoroutineNum; $i++) {
        $this->pool->push(new Coroutine());
    }
}

public function execute($callback, $data)
{
    $coroutine = $this->pool->pop();
    $coroutine->execute($callback, $data, $this->redisConfig);
    $this->pool->push($coroutine);
}

}

3. Création d'une coroutine

Ensuite, nous pouvons créer une coroutine pour effectuer des tâches.

class Coroutine
{

private $redis;

public function __construct()
{
    $this->redis = null;
}

public function execute($callback, $data, $config)
{
    if (!$this->redis) {
        $this->redis = (new RedisPool())->get($config);
    }
    
    Coroutine::create(function () use ($callback, $data) {
        call_user_func($callback, $this->redis, $data);
    });
}

}

4. Créer un service

Enfin, nous pouvons utiliser Swoole pour créer un service afin de fournir des fonctions de requête de file d'attente et d'ajout de tâches.

1. Implémenter la gestion des files d'attente

Nous pouvons utiliser le serveur HTTP de Swoole pour mettre en œuvre la surveillance des ports de service et effectuer la gestion des files d'attente via des requêtes HTTP. Nous fournissons ici des interfaces pour l'acquisition de listes, la suppression et l'ajout de tâches.

2. Implémenter l'exécution des tâches

Nous pouvons utiliser le processus TaskWorker de Swoole pour implémenter l'exécution des tâches. En distribuant des tâches au processus TaskWorker, le processus TaskWorker exécute les tâches de manière asynchrone.

class Task
{

public function execute($worker, $workerId, $taskId, $taskData)
{
    $executor = new CoroutineExecutor(64, [
        'host' => '127.0.0.1',
        'port' => 6379,
        'db' => 0
    ]);
    $executor->execute($taskData['callback'], $taskData['data']);

    return true;
}

}

3. Implémenter le démarrage du service

Enfin, nous pouvons implémenter le démarrage du service, écouter sur le port et démarrer le processus TaskWorker pour effectuer des tâches.

$http = new SwooleHttpServer("127.0.0.1", 9501);
$http->on('start', function () {

echo "Server started

";
});

$http->on ('request', fonction ($request, $response) {

$queue = new Queue([
    'host' => '127.0.0.1',
    'port' => 6379,
    'db' => 0
]);

switch ($request->server['request_uri']) {
    case '/queue/list':
        // 获取队列列表
        break;
    case '/queue/delete':
        // 删除任务
        break;
    case '/queue/add':
        $data = json_decode($request->rawContent(), true);
        $queue->push($data['queue'], $data['data']);
        $http->task([
            'callback' => function ($redis, $data) {
                // 任务执行逻辑
            },
            'data' => $data
        ]);
        break;
    default:
        $response->status(404);
        $response->end();
        break;
}

});

$http->on('task', fonction ($http, $taskId, $workerId, $data) {

$task = new Task();
$result = $task->execute($http, $workerId, $taskId, $data);

return $result;

});

$http->on('finish', function ($http, $taskId, $data) {

// 任务执行完成逻辑

});

$http->start();

5. Résumé

Cet article explique comment utiliser Swoole pour implémenter un système de file d'attente haute performance. Grâce aux coroutines et aux processus Worker de Swoole, nous pouvons obtenir un traitement haute performance des tâches asynchrones et obtenir une gestion et un contrôle efficaces des tâches via la structure de stockage Redis. Planification. Un tel système de file d'attente peut être largement utilisé dans des scénarios fonctionnels tels que la planification de tâches asynchrones, l'accès simultané élevé et l'équilibrage de charge. C'est une solution qui mérite d'être promue et utilisée.

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!