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

它更簡單，也更快。