Реализация кеша с использованием java ConcurrentHashMap

Если безопасно временно иметь более одного экземпляра для того, что вы пытаетесь кэшировать, вы можете сделать кеш «без блокировки» следующим образом:

public Heavy instance(Object key) {
  Heavy info = infoMap.get(key);
  if ( info == null ) {
    // It's OK to construct a Heavy that ends up not being used
    info = new Heavy(key);
    Heavy putByOtherThreadJustNow = infoMap.putIfAbsent(key, info);
    if ( putByOtherThreadJustNow != null ) {
      // Some other thread "won"
      info = putByOtherThreadJustNow;
    }
    else {
      // This thread was the winner
    }
  }
  return info;
}

Несколько потоков могут «состязаться» в создании и добавлении элемента для ключа, но только один из них должен «выиграть».

В дополнение к ответу Кена, если создание тяжеловесного объекта, который позже будет выброшен, НЕ приемлемо (по какой-то причине вы хотите гарантировать, что для каждого ключа создается только один объект), тогда вы можете сделать это... на самом деле, не. Не делай этого сам. Используйте коллекции Google (теперь гуава) класс MapMaker:

Map<KeyType, HeavyData> cache = new MapMaker<KeyType, HeavyData>()
  .makeComputingMap(new Function<KeyType, HeavyData>() {
      public HeavyData apply(KeyType key) {
          return new HeavyData(key); // Guaranteed to be called ONCE for each key
      }
  });

Тогда простой cache.get(key) просто работает и полностью избавляет вас от необходимости беспокоиться о сложных аспектах параллелизма и синхронизации.

Обратите внимание, что если вы хотите добавить некоторые более интересные функции, такие как истечение срока действия, это просто

Map<....> cache = new MapMaker<....>()
  .expiration(30, TimeUnit.MINUTES)
  .makeComputingMap(.....)

и вы также можете легко использовать мягкие или слабые значения для ключей или данных, если это необходимо (см. Javadoc для более подробной информации)

Вместо того, чтобы помещать «тяжелые объекты» в кеш, вы можете использовать легкие фабричные объекты для создания активного кеша.

public abstract class LazyFactory implements Serializable {

  private Object _heavyObject;

  public getObject() {
    if (_heavyObject != null) return _heavyObject;
    synchronized {
      if (_heavyObject == null) _heavyObject = create();
    }
    return _heavyObject;
  }

  protected synchronized abstract Object create();
}

// here's some sample code

// create the factory, ignore negligible overhead for object creation
LazyFactory factory = new LazyFactory() {
  protected Object create() {
    // do heavy init here
    return new DbConnection();
  };
};
LazyFactory prev = map.pufIfAbsent("db", factory);
// use previous factory if available
return prev != null ? prev.getObject() : factory.getObject;

ConcurrentHashMap должно быть достаточно для ваших нужд. putIfAbsent является потокобезопасным.

Не уверен, насколько проще вы можете получить

ConcurrentMap myCache = new ConcurrentHashMap();

Павел

Я понимаю, что это старый пост, но в java 8 это можно сделать без создания потенциально неиспользуемого тяжелого объекта с помощью ConcurrentHashMap.

public class ConcurrentCache4<K,V> {
    public static class HeavyObject
    {
    }

    private ConcurrentHashMap<String, HeavyObject> cache = new ConcurrentHashMap<>();

    public HeavyObject get(String key)
    {
        HeavyObject heavyObject = cache.get(key);
        if (heavyObject != null) {
            return heavyObject;
        }

        return cache.computeIfAbsent(key, k -> new HeavyObject());
    }
}