Questo è il secondo round.
Il primo round è stato quello che mi è venuto in mente, poi ho riletto i commenti con il dominio un po 'più radicato nella mia testa.
Quindi ecco la versione più semplice con un unit test che mostra che funziona sulla base di alcune altre versioni.
Prima la versione non concorrente:
import java.util.LinkedHashMap;
import java.util.Map;
public class LruSimpleCache<K, V> implements LruCache <K, V>{
Map<K, V> map = new LinkedHashMap ( );
public LruSimpleCache (final int limit) {
map = new LinkedHashMap <K, V> (16, 0.75f, true) {
@Override
protected boolean removeEldestEntry(final Map.Entry<K, V> eldest) {
return super.size() > limit;
}
};
}
@Override
public void put ( K key, V value ) {
map.put ( key, value );
}
@Override
public V get ( K key ) {
return map.get(key);
}
//For testing only
@Override
public V getSilent ( K key ) {
V value = map.get ( key );
if (value!=null) {
map.remove ( key );
map.put(key, value);
}
return value;
}
@Override
public void remove ( K key ) {
map.remove ( key );
}
@Override
public int size () {
return map.size ();
}
public String toString() {
return map.toString ();
}
}
La vera bandiera seguirà l'accesso di get e put. Vedi JavaDocs. RemoveEdelstEntry senza il vero flag per il costruttore implementerebbe solo una cache FIFO (vedere le note seguenti su FIFO e removeEldestEntry).
Ecco il test che dimostra che funziona come una cache LRU:
public class LruSimpleTest {
@Test
public void test () {
LruCache <Integer, Integer> cache = new LruSimpleCache<> ( 4 );
cache.put ( 0, 0 );
cache.put ( 1, 1 );
cache.put ( 2, 2 );
cache.put ( 3, 3 );
boolean ok = cache.size () == 4 || die ( "size" + cache.size () );
cache.put ( 4, 4 );
cache.put ( 5, 5 );
ok |= cache.size () == 4 || die ( "size" + cache.size () );
ok |= cache.getSilent ( 2 ) == 2 || die ();
ok |= cache.getSilent ( 3 ) == 3 || die ();
ok |= cache.getSilent ( 4 ) == 4 || die ();
ok |= cache.getSilent ( 5 ) == 5 || die ();
cache.get ( 2 );
cache.get ( 3 );
cache.put ( 6, 6 );
cache.put ( 7, 7 );
ok |= cache.size () == 4 || die ( "size" + cache.size () );
ok |= cache.getSilent ( 2 ) == 2 || die ();
ok |= cache.getSilent ( 3 ) == 3 || die ();
ok |= cache.getSilent ( 4 ) == null || die ();
ok |= cache.getSilent ( 5 ) == null || die ();
if ( !ok ) die ();
}
Ora per la versione simultanea ...
pacchetto org.boon.cache;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
public class LruSimpleConcurrentCache<K, V> implements LruCache<K, V> {
final CacheMap<K, V>[] cacheRegions;
private static class CacheMap<K, V> extends LinkedHashMap<K, V> {
private final ReadWriteLock readWriteLock;
private final int limit;
CacheMap ( final int limit, boolean fair ) {
super ( 16, 0.75f, true );
this.limit = limit;
readWriteLock = new ReentrantReadWriteLock ( fair );
}
protected boolean removeEldestEntry ( final Map.Entry<K, V> eldest ) {
return super.size () > limit;
}
@Override
public V put ( K key, V value ) {
readWriteLock.writeLock ().lock ();
V old;
try {
old = super.put ( key, value );
} finally {
readWriteLock.writeLock ().unlock ();
}
return old;
}
@Override
public V get ( Object key ) {
readWriteLock.writeLock ().lock ();
V value;
try {
value = super.get ( key );
} finally {
readWriteLock.writeLock ().unlock ();
}
return value;
}
@Override
public V remove ( Object key ) {
readWriteLock.writeLock ().lock ();
V value;
try {
value = super.remove ( key );
} finally {
readWriteLock.writeLock ().unlock ();
}
return value;
}
public V getSilent ( K key ) {
readWriteLock.writeLock ().lock ();
V value;
try {
value = this.get ( key );
if ( value != null ) {
this.remove ( key );
this.put ( key, value );
}
} finally {
readWriteLock.writeLock ().unlock ();
}
return value;
}
public int size () {
readWriteLock.readLock ().lock ();
int size = -1;
try {
size = super.size ();
} finally {
readWriteLock.readLock ().unlock ();
}
return size;
}
public String toString () {
readWriteLock.readLock ().lock ();
String str;
try {
str = super.toString ();
} finally {
readWriteLock.readLock ().unlock ();
}
return str;
}
}
public LruSimpleConcurrentCache ( final int limit, boolean fair ) {
int cores = Runtime.getRuntime ().availableProcessors ();
int stripeSize = cores < 2 ? 4 : cores * 2;
cacheRegions = new CacheMap[ stripeSize ];
for ( int index = 0; index < cacheRegions.length; index++ ) {
cacheRegions[ index ] = new CacheMap<> ( limit / cacheRegions.length, fair );
}
}
public LruSimpleConcurrentCache ( final int concurrency, final int limit, boolean fair ) {
cacheRegions = new CacheMap[ concurrency ];
for ( int index = 0; index < cacheRegions.length; index++ ) {
cacheRegions[ index ] = new CacheMap<> ( limit / cacheRegions.length, fair );
}
}
private int stripeIndex ( K key ) {
int hashCode = key.hashCode () * 31;
return hashCode % ( cacheRegions.length );
}
private CacheMap<K, V> map ( K key ) {
return cacheRegions[ stripeIndex ( key ) ];
}
@Override
public void put ( K key, V value ) {
map ( key ).put ( key, value );
}
@Override
public V get ( K key ) {
return map ( key ).get ( key );
}
//For testing only
@Override
public V getSilent ( K key ) {
return map ( key ).getSilent ( key );
}
@Override
public void remove ( K key ) {
map ( key ).remove ( key );
}
@Override
public int size () {
int size = 0;
for ( CacheMap<K, V> cache : cacheRegions ) {
size += cache.size ();
}
return size;
}
public String toString () {
StringBuilder builder = new StringBuilder ();
for ( CacheMap<K, V> cache : cacheRegions ) {
builder.append ( cache.toString () ).append ( '\n' );
}
return builder.toString ();
}
}
Puoi capire perché copro prima la versione non concorrente. Quanto sopra tenta di creare alcune strisce per ridurre la contesa di blocco. Quindi noi hash la chiave e poi cerca quell'hash per trovare la cache effettiva. Questo rende la dimensione limite più di un suggerimento / ipotesi approssimativa all'interno di una discreta quantità di errore a seconda di quanto bene sia distribuito l'algoritmo di hash delle chiavi.
Ecco il test per dimostrare che probabilmente la versione concorrente funziona. :) (Test sotto tiro sarebbe il modo reale).
public class SimpleConcurrentLRUCache {
@Test
public void test () {
LruCache <Integer, Integer> cache = new LruSimpleConcurrentCache<> ( 1, 4, false );
cache.put ( 0, 0 );
cache.put ( 1, 1 );
cache.put ( 2, 2 );
cache.put ( 3, 3 );
boolean ok = cache.size () == 4 || die ( "size" + cache.size () );
cache.put ( 4, 4 );
cache.put ( 5, 5 );
puts (cache);
ok |= cache.size () == 4 || die ( "size" + cache.size () );
ok |= cache.getSilent ( 2 ) == 2 || die ();
ok |= cache.getSilent ( 3 ) == 3 || die ();
ok |= cache.getSilent ( 4 ) == 4 || die ();
ok |= cache.getSilent ( 5 ) == 5 || die ();
cache.get ( 2 );
cache.get ( 3 );
cache.put ( 6, 6 );
cache.put ( 7, 7 );
ok |= cache.size () == 4 || die ( "size" + cache.size () );
ok |= cache.getSilent ( 2 ) == 2 || die ();
ok |= cache.getSilent ( 3 ) == 3 || die ();
cache.put ( 8, 8 );
cache.put ( 9, 9 );
ok |= cache.getSilent ( 4 ) == null || die ();
ok |= cache.getSilent ( 5 ) == null || die ();
puts (cache);
if ( !ok ) die ();
}
@Test
public void test2 () {
LruCache <Integer, Integer> cache = new LruSimpleConcurrentCache<> ( 400, false );
cache.put ( 0, 0 );
cache.put ( 1, 1 );
cache.put ( 2, 2 );
cache.put ( 3, 3 );
for (int index =0 ; index < 5_000; index++) {
cache.get(0);
cache.get ( 1 );
cache.put ( 2, index );
cache.put ( 3, index );
cache.put(index, index);
}
boolean ok = cache.getSilent ( 0 ) == 0 || die ();
ok |= cache.getSilent ( 1 ) == 1 || die ();
ok |= cache.getSilent ( 2 ) != null || die ();
ok |= cache.getSilent ( 3 ) != null || die ();
ok |= cache.size () < 600 || die();
if ( !ok ) die ();
}
}
Questo è l'ultimo post .. Il primo post che ho eliminato in quanto era una LFU non una cache LRU.
Ho pensato di fare un altro tentativo. Stavo provando a trovare la versione più semplice di una cache LRU usando il JDK standard senza troppa implementazione.
Ecco cosa mi è venuto in mente. Il mio primo tentativo è stato un po 'un disastro quando ho implementato un LFU invece di e LRU, e poi ho aggiunto FIFO e il supporto LRU ad esso ... e poi ho capito che stava diventando un mostro. Poi ho iniziato a parlare con il mio amico John che era a malapena interessato, e poi ho descritto a fondo come ho implementato un LFU, LRU e FIFO e come potevi cambiarlo con un semplice arg ENUM, e poi ho capito che tutto ciò che volevo davvero era un semplice LRU. Quindi ignora il mio precedente post e fammi sapere se vuoi vedere una cache LRU / LFU / FIFO commutabile tramite un enum ... no? Ok .. eccolo.
La LRU più semplice possibile usando solo JDK. Ho implementato sia una versione concorrente che una versione non concorrente.
Ho creato un'interfaccia comune (è un minimalismo che probabilmente mi manca alcune funzionalità che vorresti, ma funziona per i miei casi d'uso, ma lascia che tu voglia vedere la funzione XYZ fammi sapere ... Vivo per scrivere il codice.) .
public interface LruCache<KEY, VALUE> {
void put ( KEY key, VALUE value );
VALUE get ( KEY key );
VALUE getSilent ( KEY key );
void remove ( KEY key );
int size ();
}
Potresti chiederti cos'è getSilent . Lo uso per i test. getSilent non modifica il punteggio LRU di un elemento.
Prima quello non simultaneo ....
import java.util.Deque;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Map;
public class LruCacheNormal<KEY, VALUE> implements LruCache<KEY,VALUE> {
Map<KEY, VALUE> map = new HashMap<> ();
Deque<KEY> queue = new LinkedList<> ();
final int limit;
public LruCacheNormal ( int limit ) {
this.limit = limit;
}
public void put ( KEY key, VALUE value ) {
VALUE oldValue = map.put ( key, value );
/*If there was already an object under this key,
then remove it before adding to queue
Frequently used keys will be at the top so the search could be fast.
*/
if ( oldValue != null ) {
queue.removeFirstOccurrence ( key );
}
queue.addFirst ( key );
if ( map.size () > limit ) {
final KEY removedKey = queue.removeLast ();
map.remove ( removedKey );
}
}
public VALUE get ( KEY key ) {
/* Frequently used keys will be at the top so the search could be fast.*/
queue.removeFirstOccurrence ( key );
queue.addFirst ( key );
return map.get ( key );
}
public VALUE getSilent ( KEY key ) {
return map.get ( key );
}
public void remove ( KEY key ) {
/* Frequently used keys will be at the top so the search could be fast.*/
queue.removeFirstOccurrence ( key );
map.remove ( key );
}
public int size () {
return map.size ();
}
public String toString() {
return map.toString ();
}
}
Il queue.removeFirstOccurrence è un'operazione potenzialmente costoso se si dispone di una cache di grandi dimensioni. Si potrebbe prendere come esempio LinkedList e aggiungere una mappa hash di ricerca inversa da elemento a nodo per rendere le operazioni di rimozione MOLTO PIÙ RAPIDE e più coerenti. Ho iniziato anche io, ma poi ho capito che non ne avevo bisogno. Ma forse...
Quando viene chiamato put , la chiave viene aggiunta alla coda. Quando viene chiamato get , la chiave viene rimossa e aggiunta nuovamente nella parte superiore della coda.
Se la tua cache è piccola e la costruzione di un oggetto è costosa, questa dovrebbe essere una buona cache. Se la cache è davvero grande, la ricerca lineare potrebbe essere un collo di bottiglia, soprattutto se non si dispone di aree calde della cache. Più intensi sono i punti caldi, più veloce è la ricerca lineare poiché gli elementi caldi sono sempre in cima alla ricerca lineare. Ad ogni modo ... ciò che è necessario per andare più veloce è scrivere un'altra LinkedList che ha un'operazione di rimozione che ha l'elemento inverso alla ricerca del nodo per la rimozione, quindi la rimozione sarebbe rapida quanto la rimozione di una chiave da una mappa hash.
Se hai una cache con meno di 1.000 elementi, questo dovrebbe funzionare bene.
Ecco un semplice test per mostrare le sue operazioni in azione.
public class LruCacheTest {
@Test
public void test () {
LruCache<Integer, Integer> cache = new LruCacheNormal<> ( 4 );
cache.put ( 0, 0 );
cache.put ( 1, 1 );
cache.put ( 2, 2 );
cache.put ( 3, 3 );
boolean ok = cache.size () == 4 || die ( "size" + cache.size () );
ok |= cache.getSilent ( 0 ) == 0 || die ();
ok |= cache.getSilent ( 3 ) == 3 || die ();
cache.put ( 4, 4 );
cache.put ( 5, 5 );
ok |= cache.size () == 4 || die ( "size" + cache.size () );
ok |= cache.getSilent ( 0 ) == null || die ();
ok |= cache.getSilent ( 1 ) == null || die ();
ok |= cache.getSilent ( 2 ) == 2 || die ();
ok |= cache.getSilent ( 3 ) == 3 || die ();
ok |= cache.getSilent ( 4 ) == 4 || die ();
ok |= cache.getSilent ( 5 ) == 5 || die ();
if ( !ok ) die ();
}
}
L'ultima cache LRU era a thread singolo, e per favore non racchiuderla in nulla sincronizzato ....
Ecco una pugnalata a una versione concorrente.
import java.util.Deque;
import java.util.LinkedList;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.locks.ReentrantLock;
public class ConcurrentLruCache<KEY, VALUE> implements LruCache<KEY,VALUE> {
private final ReentrantLock lock = new ReentrantLock ();
private final Map<KEY, VALUE> map = new ConcurrentHashMap<> ();
private final Deque<KEY> queue = new LinkedList<> ();
private final int limit;
public ConcurrentLruCache ( int limit ) {
this.limit = limit;
}
@Override
public void put ( KEY key, VALUE value ) {
VALUE oldValue = map.put ( key, value );
if ( oldValue != null ) {
removeThenAddKey ( key );
} else {
addKey ( key );
}
if (map.size () > limit) {
map.remove ( removeLast() );
}
}
@Override
public VALUE get ( KEY key ) {
removeThenAddKey ( key );
return map.get ( key );
}
private void addKey(KEY key) {
lock.lock ();
try {
queue.addFirst ( key );
} finally {
lock.unlock ();
}
}
private KEY removeLast( ) {
lock.lock ();
try {
final KEY removedKey = queue.removeLast ();
return removedKey;
} finally {
lock.unlock ();
}
}
private void removeThenAddKey(KEY key) {
lock.lock ();
try {
queue.removeFirstOccurrence ( key );
queue.addFirst ( key );
} finally {
lock.unlock ();
}
}
private void removeFirstOccurrence(KEY key) {
lock.lock ();
try {
queue.removeFirstOccurrence ( key );
} finally {
lock.unlock ();
}
}
@Override
public VALUE getSilent ( KEY key ) {
return map.get ( key );
}
@Override
public void remove ( KEY key ) {
removeFirstOccurrence ( key );
map.remove ( key );
}
@Override
public int size () {
return map.size ();
}
public String toString () {
return map.toString ();
}
}
Le differenze principali sono l'uso di ConcurrentHashMap invece di HashMap e l'uso di Lock (avrei potuto scappare con sincronizzato, ma ...).
Non l'ho testato sotto tiro, ma sembra una semplice cache LRU che potrebbe funzionare nell'80% dei casi d'uso in cui è necessaria una semplice mappa LRU.
Accolgo con favore il feedback, tranne il motivo per cui non usi la libreria a, b o c. Il motivo per cui non uso sempre una libreria è perché non voglio sempre che ogni file di guerra sia di 80 MB e scrivo librerie, quindi tendo a rendere il plug-in libs con una soluzione abbastanza valida e qualcuno può collegarlo -in un altro provider di cache, se lo desiderano. :) Non so mai quando qualcuno potrebbe aver bisogno di Guava o ehcache o qualcos'altro che non voglio includerli, ma se rendo la cache inseribile, non li escluderò neanche.
La riduzione delle dipendenze ha una sua ricompensa. Adoro ricevere feedback su come renderlo ancora più semplice o veloce o entrambi.
Anche se qualcuno sa di un pronto per partire ....
Ok .. So cosa stai pensando ... Perché non usa semplicemente la voce removeEldest da LinkedHashMap, e dovrei ma ... ma ... ma .. Sarebbe un FIFO non un LRU e noi eravamo cercando di implementare un LRU.
Map<KEY, VALUE> map = new LinkedHashMap<KEY, VALUE> () {
@Override
protected boolean removeEldestEntry ( Map.Entry<KEY, VALUE> eldest ) {
return this.size () > limit;
}
};
Questo test fallisce per il codice sopra ...
cache.get ( 2 );
cache.get ( 3 );
cache.put ( 6, 6 );
cache.put ( 7, 7 );
ok |= cache.size () == 4 || die ( "size" + cache.size () );
ok |= cache.getSilent ( 2 ) == 2 || die ();
ok |= cache.getSilent ( 3 ) == 3 || die ();
ok |= cache.getSilent ( 4 ) == null || die ();
ok |= cache.getSilent ( 5 ) == null || die ();
Quindi ecco una cache FIFO veloce e sporca usando removeEldestEntry.
import java.util.*;
public class FifoCache<KEY, VALUE> implements LruCache<KEY,VALUE> {
final int limit;
Map<KEY, VALUE> map = new LinkedHashMap<KEY, VALUE> () {
@Override
protected boolean removeEldestEntry ( Map.Entry<KEY, VALUE> eldest ) {
return this.size () > limit;
}
};
public LruCacheNormal ( int limit ) {
this.limit = limit;
}
public void put ( KEY key, VALUE value ) {
map.put ( key, value );
}
public VALUE get ( KEY key ) {
return map.get ( key );
}
public VALUE getSilent ( KEY key ) {
return map.get ( key );
}
public void remove ( KEY key ) {
map.remove ( key );
}
public int size () {
return map.size ();
}
public String toString() {
return map.toString ();
}
}
I FIFO sono veloci. Nessuna ricerca in giro. Potresti affrontare un FIFO di fronte a un LRU e questo gestirà la maggior parte delle voci più interessanti. Un LRU migliore avrà bisogno di quell'elemento inverso alla funzione Nodo.
Comunque ... ora che ho scritto un po 'di codice, lasciami esaminare le altre risposte e vedere cosa ho perso ... la prima volta che le ho scansionate.
O(1)versione richiesta: stackoverflow.com/questions/23772102/...