Français
Français
Pendant le développement, nous devons souvent traiter de grandes quantités de données. Le traitement trop de données en même temps prendra non seulement beaucoup de temps, mais peut également provoquer un débordement de mémoire. Pour améliorer les performances et l'expérience utilisateur, nous pouvons adopter le traitement des blocs. Array_chunk est une fonction très utile intégrée à PHP, qui peut diviser un grand tableau en plusieurs petits tableaux. Combiné avec des opérations asynchrones, nous pouvons améliorer l'efficacité de l'exécution du programme pendant le groupe.
Array_chunk est l'une des fonctions PHP Array. Sa fonction consiste à diviser un grand tableau en plusieurs petits tableaux, chaque petit tableau contenant un nombre spécifié d'éléments. Cette fonction est très adaptée aux situations où de grandes quantités de données sont nécessaires et peuvent réduire efficacement l'utilisation de la mémoire.
Prototype de fonction:
array_chunk(array $array, int $size, bool $preserve_keys = false): array
$ Array : Le tableau à avoir choisi.
$ Taille : la taille de chaque petit tableau.
$ Preserve_Keys : s'il faut préserver le nom de clé du tableau d'origine (la valeur par défaut est fausse ).
Supposons que nous ayons un tableau de 1000 données et utilisons Array_Chunk pour les diviser en 10 petits tableaux, chaque petit tableau contenant 100 éléments.
<?php
$data = range(1, 1000); // générer1arriver1000Tableau de
$chunkedData = array_chunk($data, 100);
print_r($chunkedData);
?>
Résultat de sortie:
Array
(
[0] => Array ( [0] => 1 [1] => 2 ... [99] => 100 )
[1] => Array ( [0] => 101 [1] => 102 ... [99] => 200 )
...
)
De cette façon, nous divisons les grandes données de tableau de tableau en plusieurs petits tableaux, chaque petit tableau contient 100 éléments.
Après avoir utilisé Array_Chunk pour bloquer les mégadonnées, nous pouvons combiner davantage les opérations asynchrones pour améliorer les performances. Les opérations asynchrones peuvent entraîner l'exécution de plusieurs tâches en parallèle, évitant ainsi le blocage. Les opérations asynchrones peuvent être implémentées dans PHP à bien des égards, parmi lesquelles la méthode la plus courante consiste à utiliser CURL_MULTI_EXEC ou PHP Async Extension.
Supposons que nous voulons traiter les données de chaque morceau via les demandes HTTP, la méthode de traitement d'origine peut être d'initier les demandes une par une, ce qui conduira à un blocage à long terme. Nous pouvons utiliser des demandes asynchrones pour lancer plusieurs demandes en même temps en arrière-plan, améliorant ainsi l'efficacité de traitement.
<?php
$data = range(1, 1000); // Simuler les mégadonnées
$chunkedData = array_chunk($data, 100); // Block Traitement
// initialisation cURL multi handle
$mh = curl_multi_init();
// La poignée utilisée pour enregistrer chaque demande
$curlHandles = [];
// Itérer dans chaque bloc de données，Lancer de manière asynchrone une demande
foreach ($chunkedData as $index => $chunk) {
$url = "http://m66.net/api/process_data"; // HypothèseAPIadresse
$postData = json_encode(['data' => $chunk]);
$ch = curl_init($url);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, $postData);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
// 添加arriver multi handle milieu
curl_multi_add_handle($mh, $ch);
$curlHandles[$index] = $ch;
}
// Effectuer des demandes asynchrones
do {
$multiExec = curl_multi_exec($mh, $running);
if ($running) {
curl_multi_select($mh);
}
} while ($running);
// Obtenez le contenu de la réponse
foreach ($curlHandles as $index => $ch) {
$response = curl_multi_getcontent($ch);
echo "Response from chunk {$index}: " . $response . "\n";
// Fermez chaque poignée de demande
curl_multi_remove_handle($mh, $ch);
}
// fermeture multi handle
curl_multi_close($mh);
?>
Dans cet exemple, nous utilisons CURL_MULTI_EXEC pour implémenter la fonction des demandes asynchrones. Chaque bloc de données initie une demande via Curl et les traite en parallèle, améliorant considérablement les performances.
Réduire le temps d'attente : les opérations asynchrones peuvent traiter plusieurs demandes en même temps, en évitant le temps d'attente lors de la demande un par un.
Améliorer l'efficacité : pour les opérations à forte intensité d'E / S (comme les demandes HTTP), les opérations asynchrones peuvent utiliser pleinement les ressources système.
Optimiser l'utilisation des ressources : grâce à la chasse et au traitement asynchrone, nous évitons les problèmes de débordement de mémoire, tout en optimisant l'utilisation du CPU et de la bande passante du réseau.
Gestion des erreurs : Dans les opérations asynchrones, les erreurs de traitement sont particulièrement importantes. Nous devons nous assurer que le succès et l'échec de chaque demande peuvent être capturés et traités en temps opportun.
Limites des ressources : Bien que les opérations asynchrones puissent améliorer les performances, elles ne sont pas illimitées. Assurez-vous que le nombre de demandes ne dépasse pas la capacité de traitement du serveur.
Cohérence des données : dans le traitement asynchrone, assurez-vous que l'ordre de traitement de chaque bloc de données n'affecte pas le résultat final.
En utilisant la fonction Array_Chunk , nous pouvons reprendre les mégadonnées et réduire l'utilisation de la mémoire. Combiné avec des opérations asynchrones (telles que curl_multi_exec ), nous pouvons traiter plusieurs blocs de données en même temps, améliorant davantage les performances du programme. Cette méthode est particulièrement efficace lors du traitement de grandes quantités de données et peut améliorer considérablement l'expérience utilisateur, en particulier dans les scénarios où un grand nombre de demandes de réseau ou d'opérations d'E / S sont nécessaires.
