LRU算法简介

LRU是什么？

按照英文的直接原义就是Least Recently Used,最近最久未使用法，它是按照一个非常注明的计算机操作系统基础理论得来的：最近使用的页面数据会在未来一段时期内仍然被使用,已经很久没有使用的页面很有可能在未来较长的一段时间内仍然不会被使用。基于这个思想,会存在一种缓存淘汰机制，每次从内存中找到最久未使用的数据然后置换出来，从而存入新的数据！它的主要衡量指标是使用的时间，附加指标是使用的次数。在计算机中大量使用了这个机制，它的合理性在于优先筛选热点数据，所谓热点数据，就是最近最多使用的数据！因为，利用LRU我们可以解决很多实际开发中的问题，并且很符合业务场景。

1.2：小王的困惑

   当小王看到LRU的时候，瞬间感觉抓住了救命稻草，这个算法不是就完全契合产品的需求吗？只要把用户数据按照LRU去筛选，利用数据结构完成的事情，完全减少了自己存储、添加字段判断、排序的过程，这样对于提高服务器性能肯定有很大的帮助，岂不美哉！小王考虑好之后，就决定先写一个demo来实现LRU，那么在php中是如何实现LRU呢？考虑了许久。以上内容来自互联网 直接 上代码

<?php
require_once('PHPUnit/Autoload.php');
require_once(dirname(__FILE__).'/../src/LRUCache/LRUCache.php');

class LRUCacheTest extends PHPUnit_Framework_TestCase {

    public function testStartsEmpty() {
        $lru = new LRUCacheLRUCache(1000);
        $this->assertNull($lru->get(1));
    }

    public function testGet() {
        $lru = new LRUCacheLRUCache(1000);
        $key = 'key1';
        $data = 'content for key1';
        $lru->put($key, $data);
        $this->assertEquals($lru->get($key), $data);
    }

    public function testMultipleGet() {
        $lru = new LRUCacheLRUCache(1000);
        $key = 'key1';
        $data = 'content for key1';
        $key2 = 'key2';
        $data2 = 'content for key2';

        $lru->put($key, $data);
        $lru->put($key2, $data2);

        $this->assertEquals($lru->get($key), $data);
        $this->assertEquals($lru->get($key2), $data2);
    }

    public function testPut() {
        $numEntries = 1000;
        $lru = new LRUCacheLRUCache($numEntries);

        $key1 = 'mykey1';
        $value1 = 'myvaluefromkey1';

        $lru->put($key1, $value1);
        $this->assertEquals($lru->get($key1), $value1);
    }

    public function testMassivePut() {
        $numEntries = 90000;
        $lru = new LRUCacheLRUCache($numEntries);

        while($numEntries > 0) {
            $lru->put($numEntries - 899999, 'some value...');
            $numEntries--;
        }
    }

    public function testRemove() {
        $numEntries = 3;
        $lru = new LRUCacheLRUCache($numEntries);

        $lru->put('key1', 'value1');
        $lru->put('key2', 'value2');
        $lru->put('key3', 'value3');

        $ret = $lru->remove('key2');
        $this->assertTrue($ret);

        $this->assertNull($lru->get('key2'));

        // test remove of already removed key
        $ret = $lru->remove('key2');
        $this->assertFalse($ret);

        // make sure no side effects took place
        $this->assertEquals($lru->get('key1'), 'value1');
        $this->assertEquals($lru->get('key3'), 'value3');
    }

    public function testPutWhenFull() {
        $lru = new LRUCacheLRUCache(3);

        $key1 = 'key1';
        $value1 = 'value1forkey1';
        $key2 = 'key2';
        $value2 = 'value2forkey2';
        $key3 = 'key3';
        $value3 = 'value3forkey3';
        $key4 = 'key4';
        $value4 = 'value4forkey4';

        // fill the cache
        $lru->put($key1, $value1);
        $lru->put($key2, $value2);
        $lru->put($key3, $value3);

        // access some elements more often
        $lru->get($key2);
        $lru->get($key2);
        $lru->get($key3);

        // put a new entry to force cache to discard the oldest
        $lru->put($key4, $value4);

        $this->assertNull($lru->get($key1));
    }
}

<?php

namespace LRUCache;

/**
 * Class that implements the concept of an LRU Cache
 * using an associative array as a naive hashmap, and a doubly linked list
 * to control the access and insertion order.
 *
 * @author Rogério Vicente
 * @license MIT (see the LICENSE file for details)
 */
class LRUCache {

    // object Node representing the head of the list
    private $head;

    // object Node representing the tail of the list
    private $tail;

    // int the max number of elements the cache supports
    private $capacity;

    // Array representing a naive hashmap (TODO needs to pass the key through a hash function)
    private $hashmap;

    /**
     * @param int $capacity the max number of elements the cache allows
     */
    public function __construct($capacity) {
        $this->capacity = $capacity;
        $this->hashmap = array();
        $this->head = new Node(null, null);
        $this->tail = new Node(null, null);

        $this->head->setNext($this->tail);
        $this->tail->setPrevious($this->head);
    }

    /**
     * Get an element with the given key
     * @param string $key the key of the element to be retrieved
     * @return mixed the content of the element to be retrieved
     */
    public function get($key) {

        if (!isset($this->hashmap[$key])) { return null; }

        $node = $this->hashmap[$key];
        if (count($this->hashmap) == 1) { return $node->getData(); }

        // refresh the access
        $this->detach($node);
        $this->attach($this->head, $node);

        return $node->getData();
    }

    /**
     * Inserts a new element into the cache 
     * @param string $key the key of the new element
     * @param string $data the content of the new element
     * @return boolean true on success, false if cache has zero capacity
     */
    public function put($key, $data) {
        if ($this->capacity <= 0) { return false; }
        if (isset($this->hashmap[$key]) && !empty($this->hashmap[$key])) {
            $node = $this->hashmap[$key];
            // update data
            $this->detach($node);
            $this->attach($this->head, $node);
            $node->setData($data);
        }
        else {
            $node = new Node($key, $data);
            $this->hashmap[$key] = $node;
            $this->attach($this->head, $node);

            // check if cache is full
            if (count($this->hashmap) > $this->capacity) {
                // we're full, remove the tail
                $nodeToRemove = $this->tail->getPrevious();
                $this->detach($nodeToRemove);
                unset($this->hashmap[$nodeToRemove->getKey()]);
            }
        }
        return true;
    }

    /**
     * Removes a key from the cache
     * @param string $key key to remove
     * @return bool true if removed, false if not found
     */
     public function remove($key) {
       if (!isset($this->hashmap[$key])) { return false; }
       $nodeToRemove = $this->hashmap[$key];
       $this->detach($nodeToRemove);
       unset($this->hashmap[$nodeToRemove->getKey()]);
       return true;
     }

    /**
     * Adds a node to the head of the list
     * @param Node $head the node object that represents the head of the list
     * @param Node $node the node to move to the head of the list
     */
    private function attach($head, $node) {
        $node->setPrevious($head);
        $node->setNext($head->getNext());
        $node->getNext()->setPrevious($node);
        $node->getPrevious()->setNext($node);
    }

    /**
     * Removes a node from the list
     * @param Node $node the node to remove from the list
     */
    private function detach($node) {
        $node->getPrevious()->setNext($node->getNext());
        $node->getNext()->setPrevious($node->getPrevious());
    }

}

/**
 * Class that represents a node in a doubly linked list
 */
class Node {

    /**
     * the key of the node, this might seem reduntant,
     * but without this duplication, we don't have a fast way
     * to retrieve the key of a node when we wan't to remove it
     * from the hashmap.
     */
    private $key;

    // the content of the node
    private $data;

    // the next node
    private $next;

    // the previous node
    private $previous;

    /**
     * @param string $key the key of the node
     * @param string $data the content of the node
     */
    public function __construct($key, $data) {
        $this->key = $key;
        $this->data = $data;
    }

    /**
     * Sets a new value for the node data
     * @param string the new content of the node
     */
    public function setData($data) {
        $this->data = $data;
    }

    /**
     * Sets a node as the next node
     * @param Node $next the next node
     */
    public function setNext($next) {
        $this->next = $next;
    }

    /**
     * Sets a node as the previous node
     * @param Node $previous the previous node
     */
    public function setPrevious($previous) {
        $this->previous = $previous;
    }

    /**
     * Returns the node key
     * @return string the key of the node
     */
    public function getKey() {
        return $this->key;
    }

    /**
     * Returns the node data
     * @return mixed the content of the node
     */
    public function getData() {
        return $this->data;
    }

    /**
     * Returns the next node
     * @return Node the next node of the node
     */
    public function getNext() {
        return $this->next;
    }

    /**
     * Returns the previous node
     * @return Node the previous node of the node
     */
    public function getPrevious() {
        return $this->previous;
    }

}

以上代码仅供大家参考