Introduction détaillée à Yac, une autre extension de mise en cache efficace pour PHP

Qu'est-ce que Yac

Vous pouvez en fait dire d'après le nom qu'il s'agit d'une autre œuvre du maître Niao Ge. Après tout, il est le développeur principal de PHP et son travail ne nous déçoit jamais à chaque fois. On peut dire que frère Niao est la fierté de nos programmeurs chinois. Il joue un rôle décisif dans le monde PHP. Bien que la fréquence de mise à jour ne soit pas élevée, chaque article mérite d'être étudié.

Yac est un système de cache partagé sans verrouillage. Parce qu'il est sans verrouillage, il est très efficace. Apc serait plus de deux fois plus efficace que Memcached, tandis que Yac est plus rapide qu'Apc. C'est sa plus grande caractéristique.

Comparé à Memcached ou Redis, Yac est plus léger. Nous n'avons pas besoin d'installer d'autres logiciels sur le serveur. Il nous suffit d'installer cette extension pour l'utiliser. Pour les petits systèmes, en particulier les systèmes qui mettent simplement en cache des données, nous n'avons pas besoin de types de données complexes. La simple utilisation de cette extension du langage de programmation peut rendre notre développement plus pratique et plus rapide.

La méthode d'installation est également très simple. Téléchargez simplement le package d'installation depuis PECL, puis installez l'extension.

Opérations de base

Pour les opérations liées au cache, elles ne sont rien d'autre que l'ajout, la modification et la suppression de cache. Contrairement aux systèmes de mise en cache externes, lors de la sauvegarde de tableaux ou d'objets, le cache des classes d'extension PHP peut directement sauvegarder ces types de données sans les sérialiser en chaînes ni les convertir en chaînes JSON. C'est l'un des avantages d'Apc et Yac.

Ajouter et obtenir du cache

$yac = new Yac();
$yac->add('a', 'value a');
$yac->add('b', [1,2,3,4]);

$obj = new stdClass;
$obj->v = 'obj v';
$yac->add('obj', $obj);


echo $yac->get('a'), PHP_EOL; // value a
echo $yac->a, PHP_EOL; // value a


print_r($yac->get('b'));
// Array
// (
//     [0] => 1
//     [1] => 2
//     [2] => 3
//     [3] => 4
// )

var_dump($yac->get('obj'));
// object(stdClass)#3 (1) {
//     ["v"]=>
//     string(5) "obj v"
// }

Opération très simple, il suffit d'instancier une classe Yac, puis nous pouvons ajouter et obtenir le contenu du cache via la méthode add() et la méthode get() .

L'extension Yac remplace également les méthodes magiques __set() et __get(), afin que nous puissions directement exploiter le cache en exploitant des variables.

Ensuite, nous pouvons afficher les informations d'état actuelles mises en cache via la fonction info().

print_r($yac->info());
// Array
// (
//     [memory_size] => 71303168
//     [slots_memory_size] => 4194304
//     [values_memory_size] => 67108864
//     [segment_size] => 4194304
//     [segment_num] => 16
//     [miss] => 0
//     [hits] => 4
//     [fails] => 0
//     [kicks] => 0
//     [recycles] => 0
//     [slots_size] => 32768
//     [slots_used] => 3
// )

Set cache

$yac->set('a', 'new value a!');
echo $yac->a, PHP_EOL; // new value a!

$yac->a = 'best new value a!';
echo $yac->a, PHP_EOL; // best new value a!

La fonction de la fonction set() est de modifier le contenu du cache si la clé de cache actuelle existe. Si elle n'existe pas, créez un cache.

Supprimer le cache

$yac->delete('a');
echo $yac->a, PHP_EOL; // 

$yac->flush();
print_r($yac->info());
// Array
// (
//     [memory_size] => 71303168
//     [slots_memory_size] => 4194304
//     [values_memory_size] => 67108864
//     [segment_size] => 4194304
//     [segment_num] => 16
//     [miss] => 1
//     [hits] => 6
//     [fails] => 0
//     [kicks] => 0
//     [recycles] => 0
//     [slots_size] => 32768
//     [slots_used] => 0
// )

Pour la suppression d'un seul cache, on peut directement utiliser la fonction delete() pour supprimer le contenu de ce cache. Si vous souhaitez vider tout l'espace du cache, vous pouvez directement utiliser flush() pour vider tout l'espace du cache.

Espace alias

Nous avons mentionné l'espace de cache ci-dessus. En fait, lors de l'instanciation de Yac, vous pouvez transmettre une configuration d'alias au constructeur de classe Yac par défaut. De cette façon, différentes instances de Yac équivalent à être placées dans différents espaces de noms, et les caches de la même clé dans différents espaces ne s'affecteront pas.

$yacFirst = new Yac();
$yacFirst->a = 'first a!';;

$yacSecond = new Yac();
$yacSecond->a = 'second a!';

echo $yacFirst->a, PHP_EOL; // second a!
echo $yacSecond->a, PHP_EOL; // second a!

Nous utilisons l'objet Yac instancié par défaut dans ce code. Bien qu'ils soient instanciés séparément, l'espace qu'ils économisent est le même, donc la même variable s'écrasera.

$yacFirst = new Yac('first');
$yacFirst->a = 'first a!';;

$yacSecond = new Yac('second');
$yacSecond->a = 'second a!';

echo $yacFirst->a, PHP_EOL; // first a!
echo $yacSecond->a, PHP_EOL; // second a!

Lorsque nous utilisons différents paramètres d'instanciation, les mêmes a ne s'affecteront pas, ils sont stockés dans des espaces différents. Autrement dit, Yac ajoutera automatiquement un préfixe à ces Clés.

Vieillissement du cache

Enfin, le système de mise en cache aura une limite de vieillissement sur le contenu mis en cache Si un délai d'expiration est spécifié, le contenu mis en cache expirera après le délai spécifié.

$yac->add('ttl', '10s', 10);
$yac->set('ttl2', '20s', 20);
echo $yac->get('ttl'), PHP_EOL; // 10s
echo $yac->ttl2, PHP_EOL; // 20s

sleep(10);

echo $yac->get('ttl'), PHP_EOL; // 
echo $yac->ttl2, PHP_EOL; // 20s

Le cache ttl dans le code ci-dessus ne définit qu'un délai d'expiration de 10 secondes, donc après sleep() pendant 10 secondes, le ttl de sortie n'aura aucun contenu.

Il convient de noter que si le paramètre d'heure n'est pas défini, il sera efficace pendant une longue période et le délai d'expiration ne peut pas être défini à l'aide de la méthode __set(). Vous ne pouvez utiliser que set(). ou la fonction add() pour définir l’heure d’expiration.

Résumé

Et l'extension Yac est-elle aussi pratique et facile à utiliser que notre Apc ? Bien sûr, le plus important est ses performances et ses scénarios applicables ? . Pour les petits systèmes, en particulier dans les environnements d'exploitation où la configuration de la machine n'est pas si forte, ce système de cache étendu peut rendre notre développement plus rapide et plus pratique. Concernant la notion de partage sans verrouillage, on peut se référer au deuxième lien dans le document de référence ci-dessous, qui est expliqué en détail dans l'article de Frère Niao.

Code de test :

https://github.com/zhangyue0503/dev-blog/blob/master/php/202006/source/PHP%E7%9A%84%E5%8F%A6%E4%B8%80%E4%B8%AA%E9%AB%98%E6%95%88%E7%BC%93%E5%AD%98%E6%89%A9%E5%B1%95%EF%BC%9AYac.php

Apprentissage recommandé : Tutoriel vidéo php