Witam,

Chcialbym dzis pdozielic sie swoim kolejnym wynalazkiem - obsluga keszu. Jest to co prawda dopiero zalazek tego co chce zrobic, albowiem brakuje metod odpowiedzialnych za obsluge danych, niemniej sposob 'komunikacji' ze sterownikiem widac na przykladzie metody Cache::dumpCache(); Docelowo zamierzam napisac takze wiecej sterownikow, zapewniajac dostep do: APC, eAccelerator, Dummy, File, MemCache, SQLite, WinCache, XCache. Zastanawiam sie takze nad mozliwoscia przechowywania keszu w cookies.

Jednoczesnie prosze o ocene oraz komentarze - czyli ogolnie mowiac code review
Jestem otwarty na wszelkie sugestie i uwagi poparte jakimkolwiek argumentem.

Pozdrawiam serdecznie.

[PHP] pobierz, plaintext 
abstract class CacheAbstract {
 
	/**
	 * Disables object cloning
	 *
	 * @return	void		does not return any value
	 */
	protected function __clone() {
		throw new Exception('Cloning Cache objects is not allowed!');
	}
 
	/**
	 * Class constructor
	 *
	 * @return	void		does not return any value
	 */
	protected function __construct() {
	}
 
} /* class */
 
 
interface CacheDriver {
 
	/**
	 * Adds an object to the cache
	 *
	 * @param	string		stores the variable using this name, should be a cache-unique name
	 * @param	mixed		the variable to store in cache
	 * @param	integer		time-to-live of cached data
	 * @return	boolean		TRUE on success, FALSE otherwise
	 */
	public function addValue($key, $var, $ttl = 300);
 
	/**
	 * Returns a dump of all files and user variables from the cache
	 *
	 * @return	string		dump of the user variables, or NULL if an unknown error encountered
	 */
	public function dumpCache();
 
	/**
	 * Flushes (clears) the user and system cache
	 *
	 * @return	void		does not return any value
	 */
	public function flushCache();
 
	/**
	 * Provides a statistics and meta-data of caching subsystem
	 *
	 * @return	array		array containing cache statistics
	 */
	public function getStatistics();
 
	/**
	 * Fetches a stored variable from the cache
	 *
	 * @param	string		key name used to store the value
	 * @return	mixed		stored variable on success, FALSE otherwise
	 */
	public function getValue($key);
 
	/**
	 * Checks if container contains an item stored under this key name
	 *
	 * @param	string		key name used to store the value
	 * @return	boolean		TRUE if the key exists, FALSE otherwise
	 */
	public function isCached($key);
 
	/**
	 * Checks whether the chosen driver is supported by PHP installation
	 *
	 * @return	boolean		TRUE if driver can be used, FALSE otherwise
	 */
	public function isSupported();
 
	/**
	 * Removes a stored variable from the cache
	 * @param	string		key name used to store the value
	 * @return	boolean		TRUE on success, FALSE otherwise
	 */
	public function removeValue($key);
 
} /* class */
 
 
final class CacheDriverApc extends CacheAbstract implements CacheDriver {
 
	/**
	 * Adds an object to the cache
	 *
	 * @param	string		stores the variable using this name, should be a cache-unique name
	 * @param	mixed		the variable to store in cache
	 * @param	integer		time-to-live of cached data
	 * @return	boolean		TRUE on success, FALSE otherwise
	 */
	public function addValue($key, $var, $ttl = 300) {
		return apc_store($key, $var, $ttl);
	}
 
	/**
	 * Returns a dump of all files and user variables from the cache
	 *
	 * @return	string		dump of the user variables, or NULL if an unknown error encountered
	 */
	public function dumpCache() {
		return apc_bin_dump();
	}
 
	/**
	 * Flushes (clears) the user and system cache
	 *
	 * @return	void		does not return any value
	 */
	public function flushCache() {
		apc_clear_cache();
		apc_clear_cache('user');
	}
 
	/**
	 * Provides a statistics and meta-data of caching subsystem
	 *
	 * @return	array		array containing cache statistics
	 */
	public function getStatistics() {
		return array('data' => apc_cache_info('user'), 'info' => '', 'size' => '');
	}
 
	/**
	 * Fetches a stored variable from the cache
	 *
	 * @param	string		key name used to store the value
	 * @return	mixed		stored variable on success, FALSE otherwise
	 */
	public function getValue($key) {
		$var = apc_fetch($key, $result);
		if(!$result) {
			return false;
		}
		return $var;
	}
 
	/**
	 * Checks if container contains an item stored under this key name
	 *
	 * @param	string		key name used to store the value
	 * @return	boolean		TRUE if the key exists, FALSE otherwise
	 */
	public function isCached($key) {
		return (bool) apc_exists($key);
	}
 
	/**
	 * Checks whether the chosen driver is supported by PHP installation
	 *
	 * @return	boolean		TRUE if driver can be used, FALSE otherwise
	 */
	public function isSupported() {
		if(!extension_loaded('apc') || !ini_get('apc.enabled')) {
			return false;
		}
		return true;
	}
 
	/**
	 * Removes a stored variable from the cache
	 * @param	string		key name used to store the value
	 * @return	boolean		TRUE on success, FALSE otherwise
	 */
	public function removeValue($key) {
		return apc_delete($key);
	}
 
} /* class */
 
 
final class Cache extends CacheAbstract {
	private $driver;
	private $storage;
 
	/**
	 * Class constructor.
	 *
	 * @param	string		specifies primary cache driver
	 * @param	string		specifies secondary (failover) cache driver
	 * @return	object		the Cache object
	 */
	protected function __construct($driver, $failover) {
		if(!$this->loadDriver($driver)) {
			if(!$this->loadDriver($failover)) {
				$this->loadDriver('dummy');
			}
		}
	}
 
	/**
	 * Returns a dump of all files and user variables from the cache
	 *
	 * @return	string		dump of the user variables, or NULL if an unknown error encountered
	 */
	public function dumpCache() {
		return $this->storage->dumpCache();
	}
 
	/**
	 * Returns a name of currently used cache storage driver
	 *
	 * @return	string		name of used storage driver
	 */
	public function getDriver() {
		return $this->driver;
	}
 
	/**
	 * Returns the global Cache object, creating it only if it does not exist already
	 *
	 * @param	string		specifies primary cache driver
	 * @param	string		specifies secondary (failover) cache driver
	 * @return	object		the Cache object
	 */
	public static function getInstance($driver = 'file', $failover = 'dummy') {
		static $instance;
		if(!isset($instance)) {
			$instance = new Cache($driver, $failover);
		}
		return $instance;
	}
 
	/**
	 * Returns a list of available cache storage drivers
	 *
	 * @return	array		an array containing a list of available cache drivers
	 */
	public static function getStorageList() {
		$list = array();
		$directory = System::getSystemDir() . '/cache/driver';
		$dh = opendir($directory);
		while(($filename = readdir($dh)) !== false) {
			$driver = substr($filename, 0, strrpos($filename, '.'));
			if($driver != '' && $driver != '.') {
				$list[] = $driver;
			}
		}
		return $list;
	}
 
	/**
	 * Loads the specified cache driver
	 *
	 * @param	string		cache driver to load
	 * @return	boolean		TRUE on success, FALSE otherwise
	 */
	private function loadDriver($driver) {
		if(in_array($driver, $this->getStorageList())) {
			$class = 'CacheDriver' . ucfirst($driver);
			$this->storage = new $class();
			if($this->storage->isSupported()) {
				$this->driver = $driver;
				return true;
			}
		}
		return false;
	}
 
} /* class */
[PHP] pobierz, plaintext 

Robisz to dla treningu czy do użytku?
Jest tyle gotowych klas do cache że głowa mała.

Oba powody sa poprawne. Przede wszystkim chce sie czegos nauczyc, pocwiczyc, nabrac wprawy.
Przy okazji chcialem takze stworzyc wlasny framework, ktory pozniej moglbym wykorzystac.
Nie zalezy mi na poznawaniu gotowych rozwiazan, mimo ze sa sprawdzone i powszechnie stosowane.
Nie planuje bowiem wykorzystywac nabytych umiejetnosci w celach zawodowych. PHP traktuje raczej jako hobby.
Gdyby bylo inaczej, to mialbym certyfikat Zenda a nie RHCE ;-)

Cache w cookies? To ma jakiekolwiek praktyczne zastosowanie? Rozumiem że sesje, Kohana ma np. taki driver ale żeby cache? File driver jest pewnie w każdym frameworku domyślny ale jest to jedna z najwolniejszych metod. Oprócz tych driverów co je tu wymieniłeś są jeszcze Redis, SSDB, MongoDB i jeszcze nie wiadomo jakie bazy Nosql.

Ale co do FileDriver, to jest tak rozwiązane, że nazwy plików są jako md5 albo SHA1 na podstawie klucza, natomiast jest jeszcze ważna sprawa, pliki o nazwach md5 albo SHA1 są zapisywane nie tylko w tym katalogu gdzie przechowujesz cache ale jeszcze w odpowiednich podkatalogach dwuliterowych, gdzie ich nazwy to dwa pierwsze znaki w nazwach md5 albo SHA1 a nie tak żeby wszystkie pliki były w tym samym katalogu.

Stworzenie własnego frameworka wymaga dużej wiedzy. Prędzej się nauczysz jak przejrzysz dobrze kod Kohany (bo ten FW ma też takie rozwiązanie i różne drivery do cache, tworzone jako singletony) i zobacz jak to tam jest rozwiązane. Będziesz pewnie to tworzył przez kilka mies. albo i więcej, pytanie co takiego osiągniesz? No chyba że Twój FW powali na kolana Symfony2 albo Laravel

Jak to mowia, takie hobby ;-)

Przyznam szczerze ze nie rozumiem idei wrzucania plikow cache do podkatalogow, jak to opisales daro0. Jaki jest sens takiego segregowania?
Na szybko napisalem driver do obslugi cache bazujacego na plikach. Poniewaz wielokrotnie trzeba wyliczyc sumy MD5 zdecydowalem sie przechowywac je dodatkowo w tablicy:

[PHP] pobierz, plaintext 
<?php
final class CacheDriverFile extends CacheAbstract implements CacheDriver {
	private $cachedir;
	private $keys;
 
	/**
	 * Adds an object to the cache
	 *
	 * @param	string		stores the variable using this name, should be a cache-unique name
	 * @param	mixed		the variable to store in cache
	 * @param	integer		time-to-live of cached data
	 * @return	boolean		TRUE on success, FALSE otherwise
	 */
	public function addValue($key, $var, $ttl = 300) {
		if(!$fp = fopen($this->getCacheFilePath($key), 'wb')) {
			return false;
		}
		$data = '<?php $var = ' . var_export($var, true) . '; $expires = ' . (time() + $ttl) . '; ?>';
		flock($fp, LOCK_EX);
		fwrite($fp, $data);
		flock($fp, LOCK_UN);
		return true;
	}
 
	/**
	 * Opens a connection to remote cache server
	 *
	 * @param	array		data necessary to connect to cache server (eg. host, port, credentials)
	 * @return	boolean		TRUE on success, FALSE otherwise
	 */
	public function connect($config) {
		if(!is_writable($config['path'])) {
			return false;
		}
		$this->cachedir = $config['path'];
		return true;
	}
 
	/**
	 * Closes a connection to remote cache server
	 *
	 * @return	boolean		TRUE on success, false otherwise
	 */
	public function disconnect() {
		return true;
	}
 
	/**
	 * Returns a path to QCF file containing cached data
	 *
	 * @param	string		key name used to store the value
	 * @return	string		absolute path to file containing variable saved under key name
	 */
	private function getCacheFilePath($key) {
		if(!isset($this->keys[$key])) {
			$this->keys[$key] = $this->cachedir . '/' . md5($key) . '.qcf';
		}
		return $this->keys[$key];
	}
 
	/**
	 * Fetches a stored variable from the cache
	 *
	 * @param	string		key name used to store the value
	 * @return	mixed		stored variable on success, FALSE otherwise
	 */
	public function getValue($key) {
		include($this->getCacheFilePath($key));
		if(!$var || !$expires || $expires < time()) {
			$this->removeValue($key);
			return false;
		}
		return $var;
	}
 
	/**
	 * Checks if container contains an item stored under this key name
	 *
	 * @param	string		key name used to store the value
	 * @return	boolean		TRUE if the key exists, FALSE otherwise
	 */
	public function isCached($key) {
		if(!file_exists($this->getCacheFilePath($key))) {
			return false;
		}
		return true;
	}
 
	/**
	 * Checks whether the chosen driver is supported by PHP installation
	 *
	 * @return	boolean		TRUE if driver can be used, FALSE otherwise
	 */
	public function isSupported() {
		return true;
	}
 
	/**
	 * Removes a stored variable from the cache
	 * @param	string		key name used to store the value
	 * @return	boolean		TRUE on success, FALSE otherwise
	 */
	public function removeValue($key) {
		unlink($this->getCacheFilePath($key));
	}
 
} /* class */
[PHP] pobierz, plaintext 

Wszelkie sugestie mile widziane

Też na początku się zastanawiałem po co te podkatalogi ale jak przejrzałem to co jest w źródłach Kohana Core, tutaj chodzi mi o statyczną funkcję Kohana::cache to tam jest wyjaśnione, że chodzi o zapobieganie przeciążeniu systemu plików. No bo co sie stanie gdy masz gdzieś koło miliona plików w jednym katalogu?

https://kohanaframework.org/3.1/guide/api/Kohana_Core#cache

ten fragment:

[PHP] pobierz, plaintext 
// Cache file is a hash of the name
    $file = sha1($name).'.txt';
 
    // Cache directories are split by keys to prevent filesystem overload
    $dir = Kohana::$cache_dir.DIRECTORY_SEPARATOR.$file[0].$file[1].DIRECTORY_SEPARATOR;
 
[PHP] pobierz, plaintext 

Laravel ma jeszcze bardziej podzielone, tj. podkatalogi of 00 do ff czyli 2 pierwsze litery z nazw plików cache (md5) a w nich jeszcze znowu podział na podkatalogi w ten sam sposób czyli kolejne dwa znaki na bazie nazwy plików cache.

Brzmi sensownie, ale tez we wszystko bym bezgranicznie nie wierzyl. Nie mowie teraz konkretnie o tych podkatalogach, jednak jak widze pare linijek nizej chmod 777, to od razu na mysl przychodzi mi potencjalna luka w bezpieczenstwie
Niemniej jednak przekonales mnie do idei stosowania podkatalogow. W wolnej chwili naniose poprawki i rozbuduje kod.

BTW: Co sadzisz o globalnej serializacji? Tj. zastanawiam sie czy warto wszystko serializowac, bez wzgledu na wartosc oraz typ zastosowanego cache?

Co do serializacji to też chyba nie jest takie proste:
http://techblog.procurios.nl/k/news/view/3...var_export.html

Kolejna sprawa, nie za bardzo rozumiem to w Kohanie np:

[PHP] pobierz, plaintext 
return (bool) file_put_contents($dir.$file, $data, LOCK_EX);
[PHP] pobierz, plaintext 

Natomiast jest też moduł cache zamiast standowego Kohana:cache
https://kohanaframework.org/3.1/guide/api/Cache_File#set

I nie mogę załapać dlaczego w Kohana Core jest blokada LOCK_EX a w tym module File_Cache nie ma tzn. jest tak:

[PHP] pobierz, plaintext 
 try
    {
        $file->fwrite($data, $size);
        return (bool) $file->fflush();
    }
    catch (Exception $e)
    {
        throw $e;
    }
[PHP] pobierz, plaintext 

Ta blokada jest w ogóle pod Linux wymagana czy nie?

Co do Twojego przykładu, pomyśl jeszcze o odśmiecaniu (GarbageCollector), tak żeby co jakiś czas usuwać niepotrzebne i wygasłe pliki np. w taki sposób:

[PHP] pobierz, plaintext 
// 10% prawdopodobieństwa
$gc = 10;
 
// jeśli trafione
if (rand(0, 99) < $gc)
{
    $cache->garbageCollect();
}
 
[PHP] pobierz, plaintext 

To co jakiś 10 request wywali niepotrzebne już pliki.

Ciekawe zestawienie. Watpie jednak, aby ktos pakowal tak duze porcje danych do cache. Sporo interpreterow ma limit pamieci ustawiony na 64-128MB AFAIK. Wynika wiec z tego ze musialbys wsadzic (niemal) caly skrypt do cache.
Pytajac o serializacja bardziej oabwialem sie narzutu pamieci/CPU niezbednego na wykonanie serializacji przy zapisie i deserializacji przy odczycie. Z tego benchmarku wynika jednak, ze to nie powinno byc problemem.

Lockowanie ma ta zalete, ze inny watek (request) nie nadpisze Ci tych danych. Teoretycznie istnieje ryzyko, ze 2 requesty odpalone w tym samym czasie beda chcialy cos zapisac do tego pliku i wtedy jego zawartosc moze byc inna niz sie tego spodziewasz. Exclusive lock sprawia, ze inny watek nie bedzie w stanie sie w miedzyczasie dokleic do pliku i uwazam ze warto to dopisac. Sam zreszta stosuje tego locka

Przemysle odsmiecanie, choc nie jestem teraz pewien czy we wszystkich magazynach da sie to osiagnac i jaki bylby narzut.
Jezeli chodzi o pliki, to trzeba byloby sie przeiterowac po wszystkich istniejacych plikach, zaladowac je, sprawdzic czy nie wygasly i ew usunac. Musialbym jeszcze sprawdzic czy np. APC oferuje taka mozliwosc.

Zawsze możesz stworzyć "tablicę" file cache, która będzie trzymała hash i czas pliku, a potem tylko przefiltrować tablicę i usunąć pliki.

W nowym requescie tablica bedzie pusta.

Musisz ją zapisać. Wydało mi się to logiczne.

O jakich tablicach Wy w ogóle piszecie? Nic takiego się w praktyce nie wykorzystuje W praktyce najprostszy cache polega na zapisaniu serializowanych danych (tutaj można zapisywać do cache cokolwiek) do pliku w okreslonym katalogu cache z nazwą jako md5 dla tego co zapisujecie do cache (klucz), natomiast przy odczycie ważność cache sprawdzana jest przez porównanie czasu ostatniej modyfikacji pliku za pomocą filemtime() z aktualnym czasem pobranym za pomocą time(), czas ten jest liczony w sekundach, po prostu odejmuje się time() od filemtime() i jesli to jest mniejsze niż ustalony czas życia ttl, cache jest jeszcze ważna, po upływie tego czasu już należy pobrać dane na nowo i zapisac do cache.

Oczywiście należy też uwzględnić obsługę wyjątków, jak się wywali (jakiś błąd deserializacji) to też można przyjąć że cache jest nieprawidłowe i się znowu pobiera coś z bazy albo jakieś inne dane i znowu zapisuje. Oczywiście te pliki które fizycznie zostaną a upłynął czas życia wynikający z tego porównania należałoby usunąć, robi się to albo za pomocą cron-a, albo probalilistycznie, przy założeniu że wykona się to biorąc pod uwagę ilość odwiedzin. Prawdopodobieństwo można sobie ustalić np. na 1%.

A te Wasze tablice to też należałoby zapisywać do cache, żeby Wam nie zniknęły te dane, więc jak Wy sobie to wyobrażacie? I tak File Store jest jednym z najwolniejszych sposobów a Wy jeszcze macie zamiar to spowalniać zapisując serializowane tablice asocjacyjne o nie wiadomo jakiej ilości elementów? A to trzeba za każdym razem i deserializować i odczytywać a potem zapisywać. Pytanie po co?

@daro0 To oświeć mnie jak zapiszesz obiekt do Cache? Bo ja ostatnio walczyłem z FileStorage i co nie co musiałem się pogłowić żeby to sprawnie działało.

Co do tablicy to owszem, można zapuścić CRON który będzie czyścił pliki nie ważne, ale i tak musisz napisać taki mechanizm. A jeśli będziesz miał 1mln plików w podkatalogach to przelecenie wszystkich plików i sprawdzanie który przypadkiem jest przeterminowany to bzdura totalna. Dla tego moja propozycja z tablicą cache. 1 funkcja i masz listę plików które trzeba wywalić, i nie trzeba latać po katalogach i mordować I/O dysku.

Tak FileStorage to najwolniejszy z silników (cache nawet nie wspominam bo to się nie nadaje).

Tak w dużym uproszczeniu:

[PHP] pobierz, plaintext 
<?php
 
class Person
{
    public $firstname;
    public $lastname;
    public $age;
 
    public function __construct($firstname, $lastname, $age)
    {
        $this->firstname = $firstname;
        $this->lastname = $lastname;
        $this->age = $age;
    }
}
 
$person = new Person('Foo', 'Boo', 30);
 
var_dump($person);
 
$cache_file = md5('person') . '.txt';
file_put_contents($cache_file, serialize($person));
 
$person_from_cache = unserialize(file_get_contents($cache_file));
var_dump($person_from_cache);
 
?>
[PHP] pobierz, plaintext 

W czym tu jest problem? Zserializuje całą klasę jako string a po deserializacji zwróci te dane jako obiekt.

Co do odśmiecania, dlatego wydaje mi się że ten typ cache jest do małej ilości ruchu na stronie. Tak przelecieć podkatalogi trzeba by rekurencyjnie i wszystko sprawdzać. CRON podałem tylko jako przykład, natomiast czemu nie użyć odśmiecania w oparciu o random numbers? Któryś z użytkowników wejdzie na stronę i GC zadziała

A sesje to niby jaki mają mechanizm? Przecież też działa probalilistyczny garbage collector. I też przecież można by teoretycznie tworzyć miliony sesji bo jest kilka milionów użytkowników i co wtedy? Chyba podobnie.

Ja wiem że trzeba obiekt zserializować.

Ale... Chcesz to robić po stronie użytkownika? Bez sensu, dodasz serializację wszystkich danych w cachce? Też bez sensu.
Dasz serializację obiektów a potem unserialize dla wszystkich danych? Też bez sensu (wywalla błędy).

Rozwiązanie które użyłem to serializowanie tylko obiektów, i przy odczycie sprawdzanie czy string jest ciągiem zserializowanym (by regex) i jeśli tak to zrób unserialize.

Co do random number, to tak, 1% i odpala się GC. Ale żeby nie zabijać tym usera właśnie po to jest tablica cache.

Odnoszac sie do benchmarku zalaczonego przez daro0, mysle ze serializacja wszystkich danych wcale nie jest takim zlym pomyslem. Narzut wydaje sie byc znikomy, a raczej malo kto keszuje kilkudziesiecio megabajtowe dane. Poza tym to wiele upraszcza i nie trzeba pozniej sprawdzac czy potrzebna jest deserializacja czy nie. Poprostu wszystkie dane z gory traktujemy tak samo. Potencjalnie rozwiazuje to takze bugi, np. moze zwrocic zserializowanego NULLa zamiast NULLa, tak wiec konstrukcja if(!$zmienna) zadziala inaczej.

Osobiscie myslalem nad zrobieniem GC bardziej przewidywalnym i np keszowaniem ostatniego czasu wykonania GC. Po czym ustalic np. czas jego wykonania co godzine. Tak, wiec GC wykonywaloby sie nie czesciej niz raz na godzine, ew rzadziej w zaleznosci od ruchu na stronie. Jest to bardziej przewidywalne, niz probabilistyka. Random moze wygenerowac kilka razy z rzedu ta sama liczbe, albo przez tydzien w ogole jej nie wygenerowac.

To rand(0,99) jest chyba niezbyt dokładne. Można jeszcze użyć mt_rand, natomiast jakie jest prawdopodobieństwo że się trafi kilka razy pod rząd ta sama liczba? Tu zakładam że generator jest dość dobry a nie jakiś pseudo generator. Poza tym na ile jest prawdopodobne że się w katalogu cache utworzy ileś tam milionów plików a jeżeli nawet to ile one zajmują?

Weźmy np. jakieś API i pobieranie kursów walut jako JSON. Pobieranie ostatnich notowań kursów walut, oczywiście bez sensu to wywoływać za każdym razem, zwłaszcza że tu notowania są co dzień więc cache można sobie ustawić nawet na 24h. Nawet jak ktoś zechce szukać z różnymi opcjami to ile tu się tych plików utworzy? Jakiś użytkownik poczeka sobie może z 2 sekundy, reszta użytkowników będzie miała dane z cache i tu będzie ułamek sekundy, więc w czym tu jest problem?

Raczej malo trafiony przyklad
Dane pobierzesz, przeparsujesz i zapiszesz raz, obliczasz sobie pozniej dowoli.


Funkcja touch() pozwala ustawic modified time w przyszlosci. Co prawda w przyszlosc mozna wybiec jedynie o ok 11 dni, ale zawsze cos. Tak wiec po utworzeniu pliku zawierajacego dane, mozna mu zmienic mtime na time() + $ttl.
Nie ma pozniej potrzeby zapisywania czegokolwiek do keszu. Trzeba poprostu przeleciec sie po plikach, sprawdzic ich mtime i jezeli sa starsze niz aktualny timestamp, to wywalic do kosza ;-) Moze to generowac I/O, ale z cala pewnoscia mniejsze niz ladowania calego pliku do pamieci, deserializacja obiektu i sprawdzanie jego TTL. Poza tym, jezeli ktos buduje duzy serwis, to nie postawi go raczej na hostingu wspoldzielonym, tylko VPS czy wrecz dedyk. A tak bedzie mozliwosc skorzystania z bardziej zaawansowanych metod keszowania - np. Redis.


Najnowsza wersja z plikowym sterownikiem:
http://wklej.org/hash/443ec12d749/