Лямбды и putIfAbsent

ОБНОВЛЕНИЕ 2015-08-01

Метод computeIfAbsent, описанный ниже, действительно был добавлен в Java SE 8. Семантика очень близка к предварительной версии.

Кроме того, в интерфейс Map добавлен computeIfAbsent вместе с целой кучей новых методов по умолчанию. Конечно, карты вообще не могут поддерживать атомарные обновления, но новые методы значительно упрощают API.

То, что вы пытаетесь сделать, вполне разумно, но, к сожалению, оно не работает с текущей версией ConcurrentMap. Однако на подходе усовершенствование. Новая версия библиотеки параллелизма включает ConcurrentHashMapV8, который содержит новый метод computeIfAbsent. Это в значительной степени позволяет вам делать именно то, что вы хотите сделать. Используя этот новый метод, ваш пример можно переписать следующим образом:

public long addTo(String key, long value) {
    return map.computeIfAbsent( key, () -> new AtomicLong(0) ).addAndGet(value);
}

Дополнительную информацию о ConcurrentHashMapV8 см. в первоначальной ветке объявлений в списке рассылки параллелизма. Несколько сообщений ниже по цепочке представляют собой дополнительное сообщение, которое показывает пример, очень похожий на то, что вы пытаетесь сделать. (Обратите внимание на старый синтаксис лямбда. В конце концов, это сообщение было от августа 2011 года.) А вот последний документ Java для ConcurrentHashMapV8.

Эта работа предназначена для интеграции в Java 8, но, насколько я понимаю, пока этого не произошло. Кроме того, это все еще находится в стадии разработки, имена и характеристики могут измениться и т. д.

AtomicLong на самом деле не тяжелый объект. Для более тяжелых объектов я бы рассмотрел ленивый прокси-сервер и предоставил ему лямбду для создания объекта, если это необходимо.

class MyObject{
    void doSomething(){}
}

class MyLazyObject extends MyObject{
    Funktion create;
    MyLazyObject(Funktion create){
        this.create = create;
    }
    MyObject instance;
    MyObject getInstance(){
        if(instance == null)
            instance = create.apply();
        return instance;
    }
    @Override void doSomething(){getInstance().doSomething();}
}

public long addTo(String key, long value) {
  return map.putIfAbsent( key, new MyLazyObject( () -> new MyObject(0) ) );
}

К сожалению, это не так просто. Есть две основные проблемы с подходом, который вы набросали: 1. Тип карты должен измениться с Map<String, AtomicLong> на Map<String, AtomicLongFunction> (где AtomicLongFunction — это некоторый функциональный интерфейс, который имеет единственный метод, который не принимает аргументов и возвращает AtomicLong) . 2. Когда вы извлекаете элемент из карты, вам нужно каждый раз применять функцию, чтобы получить из него AtomicLong. Это приведет к созданию нового экземпляра каждый раз, когда вы его извлекаете, что вряд ли вам нужно.

Идея иметь карту, которая запускает функцию по запросу для заполнения пропущенных значений, тем не менее, хороша, и на самом деле в библиотеке Google Guava есть карта, которая делает именно это; см. их MapMaker. На самом деле этот код выиграет от лямбда-выражений Java 8: вместо

   ConcurrentMap<Key, Graph> graphs = new MapMaker()
       .concurrencyLevel(4)
       .weakKeys()
       .makeComputingMap(
           new Function<Key, Graph>() {
             public Graph apply(Key key) {
               return createExpensiveGraph(key);
             }
           });

вы могли бы написать

   ConcurrentMap<Key, Graph> graphs = new MapMaker()
       .concurrencyLevel(4)
       .weakKeys()
       .makeComputingMap((Key key) -> createExpensiveGraph(key));

or

   ConcurrentMap<Key, Graph> graphs = new MapMaker()
       .concurrencyLevel(4)
       .weakKeys()
       .makeComputingMap(this::createExpensiveGraph);

Обратите внимание, что при использовании Java 8 ConcurrentHashMap совершенно необязательно иметь значения AtomicLong. Вы можете безопасно использовать ConcurrentHashMap.merge:

ConcurrentMap<String, Long> map = new ConcurrentHashMap<String, Long>();

public long addTo(String key, long value) {
    return map.merge(key, value, Long::sum);
}

Это намного проще, а также значительно быстрее.