Français
Français
Lors du traitement des fichiers volumineux, la fonction HASH_UPDATE de PHP est souvent utilisée pour hacher le contenu du fichier, tel que le calcul des valeurs de hachage telles que MD5, SHA-1 ou SHA-256 plus sécurisée. Cependant, l'utilisation de Hash_update peut rencontrer des goulots d'étranglement de performances pour les fichiers volumineux, principalement manifestés comme une consommation excessive de mémoire ou une vitesse de calcul lente. Cet article explorera plusieurs moyens efficaces d'améliorer les performances de Hash_update , avec un exemple de code.
La lecture du fichier entier directement dans la mémoire, puis le hachage, il peut provoquer un débordement de mémoire ou une inefficacité. La meilleure pratique consiste à utiliser la méthode de lecture en morceaux pour transmettre progressivement les données à Hash_update .
<?php
$filename = '/path/to/large/file.zip';
$context = hash_init('sha256');
$handle = fopen($filename, 'rb');
if ($handle === false) {
die('Failed to open file');
}
while (!feof($handle)) {
$buffer = fread($handle, 8192); // 8KB Chaque lecture
hash_update($context, $buffer);
}
fclose($handle);
$hash = hash_final($context);
echo "File hash: $hash\n";
?>
Ici, la taille de tampon de 8KB est utilisée, qui peut être ajustée en fonction de la mémoire du système et des performances IO.
La taille du tampon affecte directement les performances de lecture et d'écriture. Trop petit conduira à une grande quantité d'opérations IO, et trop grand prendra trop de mémoire. D'une manière générale, 8 Ko à 64 Ko est un bon choix. Les meilleures performances peuvent être testées en ajustant le deuxième paramètre de Fread .
La fonction HASH_FILE fournie avec PHP est généralement plus efficace dans l'implémentation sous-jacente que le bloc de lecture par bloc de scripts PHP. Si vous calculez simplement la valeur de hachage, vous pouvez envisager de l'utiliser directement:
<?php
$hash = hash_file('sha256', '/path/to/large/file.zip');
echo "File hash: $hash\n";
?>
Cette méthode ne vous oblige pas à gérer vous-même les pointeurs de fichiers, et il sera également meilleur dans les performances.
Si l'environnement le permet, vous pouvez diviser le fichier en plusieurs parties et utiliser plusieurs processus ou plusieurs threads pour calculer le hachage pour chaque pièce séparément, et enfin fusionner les résultats (par exemple en personnalisant ou en fusionnant le hachage partiel). PHP ne prend pas en charge le multithreading nativement, mais peut être implémenté avec PCNTL_FORK ou externes.
Cependant, cette solution est complexe et a des exigences particulières pour la mise en œuvre de l'algorithme de hachage, et convient généralement aux fichiers particulièrement volumineux et aux scénarios spéciaux.
Lorsque le fichier ne change pas fréquemment, vous pouvez considérer le cache la valeur de hachage du fichier pour réduire les calculs répétés.
Par exemple, enregistrez le dernier temps de modification et la valeur de hachage du fichier d'abord:
<?php
$filename = '/path/to/large/file.zip';
$cacheFile = '/tmp/file_hash_cache.json';
$cache = json_decode(file_get_contents($cacheFile) ?: '{}', true);
$filemtime = filemtime($filename);
if (isset($cache[$filename]) && $cache[$filename]['mtime'] === $filemtime) {
$hash = $cache[$filename]['hash'];
} else {
$hash = hash_file('sha256', $filename);
$cache[$filename] = ['mtime' => $filemtime, 'hash' => $hash];
file_put_contents($cacheFile, json_encode($cache));
}
echo "File hash: $hash\n";
?>
Cela évite de recalculer le hachage à chaque fois.
Les performances de différents algorithmes de hachage varient considérablement. MD5 et SHA-1 sont généralement plus rapides que SHA-256, mais sont moins sécurisés. Choisissez l'algorithme approprié en fonction de la vitesse de compromis et des besoins de sécurité du scénario.
LECTURE DE BLOC : Évitez de lire dans la mémoire en même temps, utilisez la lecture du bloc et appelez Hash_update .
Ajustez la taille du tampon : sélectionnez raisonnablement la taille du tampon pour améliorer les performances IO.
Utilisez la fonction HASH_FILE : Fonction de fichier de hachage de hachage PHP Fonction de hachage du fichier avec des performances supérieures.
Traitement parallèle : vous pouvez essayer des calculs de rupture multiproce pour les fichiers super-grands.
Résultats du hachage de cache : Évitez les calculs répétés de fichiers inchangés.
Choisissez le bon algorithme : choisissez l'algorithme de hachage en fonction des compromis de vitesse et de sécurité.
La maîtrise de ces techniques peut améliorer considérablement les performances des programmes PHP lors de la gestion des hachages de fichiers importants.
<?php
// Exemple de code：Lisez des fichiers en morceaux et utilisez-les hash_update calculer SHA-256
$filename = 'https://gitbox.net/path/to/large/file.zip';
$context = hash_init('sha256');
$handle = fopen($filename, 'rb');
if ($handle === false) {
die('Failed to open file');
}
while (!feof($handle)) {
$buffer = fread($handle, 65536); // 64KB
hash_update($context, $buffer);
}
fclose($handle);
$hash = hash_final($context);
echo "File hash: $hash\n";
?>
