CareerCup

Code from "Java concurrency in Practice"

public class Memoizer<A, V> implements Computable<A, V> {
    private final ConcurrentMap<A, Future<V>> cache
        = new ConcurrentHashMap<A, Future<V>>();
    private final Computable<A, V> c;

    public Memoizer(Computable<A, V> c) { this.c = c; }

    public V compute(final A arg) throws InterruptedException {
        while (true) {
            Future<V> f = cache.get(arg);
            if (f == null) {
                Callable<V> eval = new Callable<V>() {
                    public V call() throws InterruptedException {
                        return c.compute(arg);
                    }
                };
                FutureTask<V> ft = new FutureTask<V>(eval);
                f = cache.putIfAbsent(arg, ft);
                if (f == null) { f = ft; ft.run(); }
            }
            try {
                return f.get();
            } catch (CancellationException e) {
                cache.remove(arg, f);
            } catch (ExecutionException e) {
                throw launderThrowable(e.getCause());
            }
        }
    } }

it is a hashmap implementation. well, a cache is a sort of hashmap

where is our dear write back and write through function :)

It looks like hashmap with cache properties, like it should have some ability to remove values when the cache is full implement something like LRU.

Actually you dont even need to implement nothing for LRU cache, read java doc for LinkedMashMap if you create it with three parametres

new LinkedHashMap(capacity,loadFactor,accessOrder)

Where accessOrder == true, then map will behave like LRU cache with established capacity.