Question

In Java, I want to do something like this:

   Object r = map.get(t);
   if (r == null) {
      r = create(); // creating r is an expensive operation.
      map.put(t, r);  
   }

Now that snippet of code can be executed in a multithreaded environment.
map can be a ConcurrentHashMap.

But how do I make that logic atomic?

Please don’t give me trivial solution like a ‘synchronized’ block.
I ‘d expect this problem can be solved neatly once and for all.

Answer 1

I think the solution is documented in concurrency in practice.
The trick is to use a Future instead of R as object in the map.

Although I dislike this answer because it looks far far too complex.

here is the code:

public class Memorizer<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 Memorizer(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());
       }
    }
}