Memoize.java

package util;

import com.google.common.base.Function;
import com.google.common.base.Optional;

import javax.annotation.Nullable;
import java.util.concurrent.*;

public class Memoize {

    public static <S, T> Function<S, T> memoize(final Function<S, T> func) {
        final ConcurrentHashMap<S, Future<T>> futures = new ConcurrentHashMap<>();
        return new Function<S, T>() {
            @Nullable
            @Override
            public T apply(@Nullable final S s) {
                FutureTask<T> newFuture = new FutureTask<>(new Callable<T>() {
                    @Override
                    public T call() throws Exception {
                        return func.apply(s);
                    }
                });
                Future<T> future = Optional.fromNullable(futures.putIfAbsent(s, newFuture)).or(newFuture);
                try {
                    return future.get();
                } catch (InterruptedException|ExecutionException e) {
                    throw new RuntimeException(e);
                }
            }
        };
    }

    public static <S, T> Function<S, Callable<T>> memoize2(final Function<S, T> func) {
        final ConcurrentHashMap<S, Future<T>> futures = new ConcurrentHashMap<>();
        return new Function<S, Callable<T>>() {
            @Nullable
            @Override
            public Callable<T> apply(@Nullable final S s) {
                FutureTask<T> newFuture = new FutureTask<>(new Callable<T>() {
                    @Override
                    public T call() throws Exception {
                        return func.apply(s);
                    }
                });
                final Future<T> future = Optional.fromNullable(futures.putIfAbsent(s, newFuture)).or(newFuture);
                return new Callable<T>() {
                    @Override
                    public T call() throws Exception {
                        return future.get();
                    }
                };
            }
        };
    }

}