lambda表达式和的putIfAbsent

Question

我张贴解答here，其中展示了使用ConcurrentMap的putIfAbsent方法的代码如下：

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

public long addTo(String key, long value) { 
    // The final value it became. 
    long result = value; 
    // Make a new one to put in the map. 
    AtomicLong newValue = new AtomicLong(value); 
    // Insert my new one or get me the old one. 
    AtomicLong oldValue = map.putIfAbsent(key, newValue); 
    // Was it already there? Note the deliberate use of '!='. 
    if (oldValue != newValue) { 
    // Update it. 
    result = oldValue.addAndGet(value); 
    } 
    return result; 
} 

这种方法的主要缺点是，你必须创建一个新的对象装进映射它是否会被使用。如果物体很重，这可能会产生重大影响。

我突然想到，这将是使用Lambda表达式的机会。我没有下载Java 8 n'or我将能够，直到它是正式的（公司政策），所以我不能测试这个，但这样的事情是有效的和有效的？

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

我希望能使用拉姆达延迟new AtomicLong(0)的评价，直到它实际上是决定了它应建立，因为它没有在地图上存在。

正如你可以看到这是更简洁和实用。

从本质上讲，我想我的问题是：

1. 将这项工作？
2. 还是我完全曲解lambda表达式？
3. 这样的工作有一天可能会奏效吗？

Answer 1

UPDATE 2015年8月1日

如下所述确实已经added to Java SE 8的computeIfAbsent方法。语义看起来非常接近预发布版本。

此外，computeIfAbsent以及一整套新的默认方法已被添加到Map界面。当然，地图通常不支持原子更新，但新方法为API增加了相当多的便利。

---

你试图做的是比较合理的，但遗憾的是它不与ConcurrentMap当前版本。然而，正在进行一项改进。新版本的并发库包含ConcurrentHashMapV8，其中包含一个新方法computeIfAbsent。这几乎可以让你做到你想要做的。使用这种新方法，如下所示的例子可以改写：

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

有关ConcurrentHashMapV8的更多信息，请参阅并发利益邮件列表上Doug Lea的initial announcement thread。线下的几条消息是a followup message，它显示了一个非常类似于你想要做的例子。 （不过请注意旧的lambda语法，那条消息是从2011年8月开始的。）这里是recent javadoc为ConcurrentHashMapV8。

本工作旨在集成到Java 8中，但它还没有据我所知。此外，这仍然是一项工作，名称和规格可能会发生变化等。

Answer 2

可惜这不是这么简单。您绘制的方法存在两个主要问题： 1.地图的类型需要从Map<String, AtomicLong>更改为Map<String, AtomicLongFunction>（其中AtomicLongFunction是一些函数接口，其中有一个方法不带参数并返回AtomicLong ）。 2.当您检索从地图元素你需要每次都获得AtomicLong出来的应用功能。这会导致每次检索它时都会创建一个新实例，这可能不是您想要的。

具有按需运行的功能，以填补缺失值是一个很好的，但是，事实上，谷歌的番石榴库有一个地图，正是这么做的地图的想法;看到他们的MapMaker。事实上该代码将受益于Java的8 lambda表达式：不是

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)); 

或

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

Answer 3

AtomicLong是不是一个真正的重物。对于较重的对象，我会考虑一个懒惰的代理，并提供一个lambda到那个创建对象，如果需要的话。

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))); 
} 

Answer 4

请注意，使用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); 
} 

它更简单，也更快。