JavaScript版的TwoQueues快取模型_基礎知識

Das in diesem Artikel erwähnte TwoQueues-Caching-Modell bezieht sich auf das Caching-Modell von Daten im Speicher.

Unabhängig von der Sprache müssen Sie möglicherweise einige Daten im Speicher ablegen, um wiederholte Vorgänge und Lesevorgänge zu vermeiden. Das häufigste Szenario ist der JQuery-Selektor. Die Auswahl einiger Dom-Elemente ist sehr zeitaufwändig. Wir hoffen, diese Daten zwischenzuspeichern, ohne den Dom-Baum bei jedem Aufruf erneut durchlaufen zu müssen.

Einfach speichern, aber es muss ein Betrag vorhanden sein! Es ist unmöglich, alle historischen Daten im Speicher abzulegen. Selbst wenn der Speicher groß genug ist, ist der jedem Thread zugewiesene Speicher begrenzt.

Die Frage ist also: Wie können wir wirklich nützliche Daten effizient zwischenspeichern? Hierbei handelt es sich um Eliminierungsalgorithmen, die Junk-Daten eliminieren müssen, um nützliche Daten zu behalten.

Die am häufigsten verwendeten Ideen sind wie folgt:

FIFO: Es handelt sich um eine First-in-First-out-Warteschlange. Die ersten zwischengespeicherten Daten werden als erste eliminiert. Dieses Modell wird im berühmten JQuery-Framework verwendet.

LRU: Doppelt verknüpfte Listenstruktur. Jedes Mal, wenn neue Daten gespeichert werden, werden sie bei jedem Zugriff auf die Daten auch an den Kopf der verknüpften Liste übertragen Auf diese Weise sind die Daten am Ende der verknüpften Liste die aktuellsten. Diejenigen, die nicht verwendet wurden, werden gelöscht.

TwoQueues: FIFO LRU, FIFO speichert hauptsächlich die zum ersten Mal gespeicherten Daten und LRU speichert Hotspot-Daten, die mindestens zweimal verwendet wurden. Dieser Algorithmus weist eine hohe Trefferquote, starke Anpassungsfähigkeit und geringe Komplexität auf.

Es gibt viele andere Eliminierungsalgorithmen, aber diese beiden werden am häufigsten verwendet. Weil ihre Algorithmen nicht komplex und einfach zu implementieren sind, eine hohe Ausführungseffizienz aufweisen und die Cache-Trefferquote in den meisten Situationen akzeptabel ist. Schließlich verbraucht der Caching-Algorithmus auch CPU, obwohl die Trefferquote verbessert wird, ist der Gewinn den Verlust nicht wert. Stellen Sie sich vor: Wenn das Abrufen von Daten aus dem Cache mehr Zeit in Anspruch nimmt als das Abrufen vom ursprünglichen Speicherort, welchen Nutzen hat dann das Caching?

Ich werde nicht näher auf die spezifische Theorie eingehen. Es gibt viele im Internet, aber ich verstehe sie nicht wirklich. Was ich heute mit Ihnen teilen möchte, ist die JavaScript-Version des TwoQueues-Caching-Modells.

Lassen Sie uns zunächst über die Verwendung sprechen. Es ist ganz einfach.

Die grundlegende Verwendung ist wie folgt:

[/code]
var tq = initTwoQueues(10);
tq.set("key", "value");
tq.get("key");
[/code]

Geben Sie bei der Initialisierung einfach die Cache-Kapazität an. Es ist zu beachten, dass aufgrund der internen Implementierung von FIFO LRU die tatsächliche Kapazität doppelt so hoch ist wie die angegebene Kapazität. Das obige Beispiel gibt 10 (Schlüssel-Wert-Paare) an, tatsächlich können jedoch 20 gespeichert werden.

Die Kapazitätsgröße muss entsprechend dem tatsächlichen Anwendungsszenario bestimmt werden. Ist sie zu klein, ist die Trefferquote gering, ist sie zu groß, ist die Effizienz gering.

Während des Entwicklungsprozesses können Sie den Cache-Pool auf die Entwicklungsversion initialisieren, um den Cache-Effekt zu überprüfen:

Code kopieren Der Code lautet wie folgt:

var tq = initTwoQueues(10, true);
tq.hitRatio();

Fügen Sie am Ende einfach einen Parameter hinzu und machen Sie ihn wahr. Der auf diese Weise initialisierte Cache-Pool zählt automatisch die Trefferquote, und die Trefferquote kann über die hitRatio-Methode ermittelt werden. Wenn dieser Parameter nicht hinzugefügt wird, beträgt die von der hitRatio-Methode erhaltene Trefferquote immer 0.
Die statistische Trefferquote wird definitiv Ressourcen verbrauchen, daher wird nicht empfohlen, sie in einer Produktionsumgebung zu aktivieren.
Zeit, den Code zu teilen:

Code kopieren Der Code lautet wie folgt:

 (Funktion(Exporte){
     /**
* Reine Klasse zur Vererbung
* @constructor
​​*/
     Funktion Fn(){}
     Fn.prototype = Elimination.prototype;
     /**
* * Elternklasse des verknüpften, listenbasierten Cache-Eliminierungsalgorithmus
* @param maxLength Cache-Kapazität
* @constructor
​​*/
     Funktion Elimination(maxLength){
         this.container = {};
         this.length = 0;
         this.maxLength = maxLength || 30;
         this.linkHead = this.buildNode("", "");
         this.linkHead.head = true;
         this.linkTail = this.buildNode("", "");
         this.linkTail.tail = true;
         this.linkHead.next = this.linkTail;
         this.linkTail.prev = this.linkHead;
     }
     Elimination.prototype.get = function(key){
         throw new Error("Diese Methode muss überschrieben werden!");
     };
     Elimination.prototype.set = function(key, value){
         throw new Error("Diese Methode muss überschrieben werden!");
     };
     /**
*Knoten in der verknüpften Liste erstellen
* @param data Die im Knoten enthaltenen Daten, also der zwischengespeicherte Datenwert
* @param key Die eindeutige Kennung des Knotens, also der zwischengespeicherte Schlüssel
* @returns {{}}
​​*/
     Elimination.prototype.buildNode = function(data, key){
         var node = {};
         node.data = data;
         node.key = key;
         node.use = 0;
         Rückkehrknoten;
     };
     /**
* Einen Knoten vom Kopf der verknüpften Liste entfernen
* @returns {*}
​​*/
     Elimination.prototype.shift = function(){
         var node = null;
         if(!this.linkHead.next.tail){
             node = this.linkHead.next;
             this.linkHead.next = node.next;
             node.next.prev = this.linkHead;
             lösche this.container[node.key];
             this.length--;
         }
         Rückkehrknoten;
     };
     /**
* Fügen Sie einen Knoten vom Kopf der verknüpften Liste
ein * @param Knoten Knotenobjekt
* @returns {*}
​​*/
     Elimination.prototype.unshift = function(node){
         node.next = this.linkHead.next;
         this.linkHead.next.prev = node;
         this.linkHead.next = node;
         node.prev = this.linkHead;
         this.container[node.key] = node;
         this.length ;
         Rückkehrknoten;
     };
     /**
      * 从链表尾插入一个节点
      * @param node 節點物件
      * @returns {*}
      */
     Elimination.prototype.append = function(node){
         this.linkTail.prev.next = 節點;
         node.prev = this.linkTail.prev;
         node.next = this.linkTail;
         this.linkTail.prev = 節點;
         this.container[node.key] = 節點;
         this.長度;
         返回節點；
     };
     /**
      * 從鍊錶尾彈出一個節點
      * @returns {*}
     */
     Elimination.prototype.pop = function(){
         var 節點 = null;
         if(!this.linkTail.prev.head){
             節點 = this.linkTail.prev;
             node.prev.next = this.linkTail;
             this.linkTail.prev = node.prev;
             刪除 this.container[node.key];
             this.length--;
         }
         返回節點；
     };
     /**
      * 從鍊錶移除指定節點
      * @param node 節點物件
      * @returns {*}
     */
     Elimination.prototype.remove = function(node){
         node.prev.next = node.next;
         node.next.prev = node.prev;
         刪除 this.container[node.key];
         this.length--;
         返回節點；
     };
     /**
      * 節點被存取需要做的處理，具體是把該節點移到鍊錶頭
      * @param node
     */
     Elimination.prototype.use = function(node){
         this.remove(節點);
         this.unshift(節點);
     };
 
     /**
      * LRU快取淘汰演算法實作
      * @constructor
     */
     函數 LRU(){
         Elimination.apply(this,arguments);
     }
     LRU.prototype = new Fn();
     LRU.prototype.get = function(key){
         var 節點 = 未定義;
         節點 = this.container[key];
         if(節點){
             this.use(節點);
         }
         返回節點；
     };
     LRU.prototype.set = function(key, value){
         var node = this.buildNode(value, key);
         if(this.length === this.maxLength){
             this.pop();
         }
         this.unshift(節點);
     };
 
     /**
      * FIFO快取淘汰演算法實作
      * @constructor
     */
     函數 FIFO(){
         Elimination.apply(this, arguments);
     }
     FIFO.prototype = new Fn();
     FIFO.prototype.get = function(key){
         var node = undefiniert;
         node = this.container[key];
         Rückkehrknoten;
     };
     FIFO.prototype.set = function(key, value){
         var node = this.buildNode(value, key);
         if(this.length === this.maxLength){
             this.shift();
         }
         this.append(node);
     };
 
     /**
* Kapselung des LRU- und FIFO-Algorithmus, wodurch der neue Zwei-Warteschlangen-Cache-Eliminierungsalgorithmus entsteht
* @param maxLength
* @constructor
​​*/
     Funktion Agent(maxLength){
         this.getCount = 0;
         this.hitCount = 0;
         this.lir = neues FIFO(maxLength);
         this.hir = new LRU(maxLength);
     }
     Agent.prototype.get = function(key){
         var node = undefiniert;
         node = this.lir.get(key);
         if(node){
             node.use ;
             if(node.use >= 2){
                 this.lir.remove(node);
                 this.hir.set(node.key, node.data);
             }
         }else{
             node = this.hir.get(key);
         }
         Rückkehrknoten;
     };
     Agent.prototype.getx = function(key){
         var node = undefiniert;
         this.getCount ;
         node = this.get(key);
         if(node){
             this.hitCount ;
         }
         Rückkehrknoten;
     };
     Agent.prototype.set = function(key, value){
         var node = null;
         node = this.lir.container[key] || this.hir.container[key];
         if(node){
             node.data = value;
         }else{
             this.lir.set(key, value);
         }
     };
     /**
* Trefferquote erhalten
* @returns {*}
​​*/
     Agent.prototype.hitRatio = function(){
         var ret = this.getCount;
         if(ret){
             ret = this.hitCount / this.getCount;
         }
         return ret;
     };
     /**
      * 对外接口
* @param maxLength Cache-Kapazität
* @param dev Unabhängig davon, ob es sich um eine Entwicklungsumgebung handelt, zählt die Entwicklungsumgebung die Trefferquote, andernfalls nicht
* @returns {{get, set: Function, hitRatio: Function}}
*/
exports.initTwoQueues = function(maxLength, dev){
        var api = new Agent(maxLength);
          return {
                get: (function(){
If(dev){
Rückgabefunktion (Taste){
                          var ret = api.getx(key);
                                           return ret && ret.data;
                      };
                     }else{
Rückgabefunktion (Taste){
                        var ret = api.get(key);
                                           return ret && ret.data;
                      };
                 }
             }()),
               set: function(){
api.set.apply(api, arguments);
             },
hitRatio: function(){
                          return api.hitRatio.apply(api, arguments);
            }
          };
};

}(dies));

Abschließend möchte ich Sie noch einmal daran erinnern, dass der Caching-Algorithmus mit dem tatsächlichen Anwendungsszenario kombiniert werden muss. Es gibt keinen universellen Algorithmus und der geeignete ist der beste!