ca.uhn.hl7v2.concurrent.BlockingHashMap Maven / Gradle / Ivy
package ca.uhn.hl7v2.concurrent;
import java.util.Collection;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.Callable;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
/**
* Default Implementation of a {@link BlockingMap}.
*
* Note: While it is not actively prevented that more then one thread waits for
* an entry, it is not guaranteed that all waiting threads will receive the
* entry once it became available. Other implementations may choose to count the
* waiting threads and/or to remove an available value after a grace period.
*
* @param
* @param
*/
public class BlockingHashMap implements BlockingMap {
private final ConcurrentMap map = new ConcurrentHashMap();
private final ConcurrentMap latches = new ConcurrentHashMap();
private final ExecutorService executor;
public BlockingHashMap() {
this(Executors.newCachedThreadPool());
}
public BlockingHashMap(ExecutorService executor) {
super();
this.executor = executor;
}
/**
* Returns the keys of available entries
*
* @see java.util.Map#keySet()
*/
public Set keySet() {
return map.keySet();
}
/**
* Returns an available entry without removing it from the map
*
* @see java.util.Map#get(java.lang.Object)
*/
public V get(Object key) {
return map.get(key);
}
/**
* Returns true if an entry with the given key is available
*
* @see java.util.Map#containsKey(java.lang.Object)
*/
public boolean containsKey(Object key) {
return map.containsKey(key);
}
/**
* @see java.util.Map#put(java.lang.Object, java.lang.Object)
*/
synchronized public V put(K key, V value) {
V result = map.put(key, value);
latchFor(key).countDown();
return result;
}
/**
* @see ca.uhn.hl7v2.concurrent.BlockingMap#give(java.lang.Object,
* java.lang.Object)
*/
synchronized public boolean give(K key, V value) {
if (!latches.containsKey(key)) {
return false;
}
put(key, value);
return true;
}
public V take(K key) throws InterruptedException {
latchFor(key).await();
latches.remove(key);
return map.remove(key); // likely to fail there are n > 1 consumers
}
public Future asyncTake(final K key) throws InterruptedException {
latchFor(key);
return executor.submit(new Callable() {
public V call() throws Exception {
return take(key);
}
});
}
public V poll(K key, long timeout, TimeUnit unit)
throws InterruptedException {
if (latchFor(key).await(timeout, unit)) {
latches.remove(key);
return map.remove(key);
}
return null;
}
public Future asyncPoll(final K key, final long timeout, final TimeUnit unit) {
latchFor(key);
return executor.submit(new Callable() {
public V call() throws Exception {
return poll(key, timeout, unit);
}
});
}
/**
* Returns true if no entry is available for consumers
*
* @see java.util.Map#isEmpty()
*/
public boolean isEmpty() {
return map.isEmpty();
}
/**
* Returns the number of available values
*
* @see java.util.Map#size()
*/
public int size() {
return map.size();
}
/**
* Removes an entry, regardless whether a value has been set or not. Waiting
* consumers will receive a null value.
*
* @see java.util.Map#remove(java.lang.Object)
*/
synchronized public V remove(Object key) {
V result = map.remove(key);
CountDownLatch latch = latches.remove(key);
if (latch != null)
latch.countDown();
return result;
}
/**
* Clears all existing entries. Waiting consumers will receive a null value
* for each removed entry.
*
* @see java.util.Map#clear()
*/
public void clear() {
for (K key : latches.keySet()) {
remove(key);
}
}
public Collection values() {
return map.values();
}
public Set> entrySet() {
return map.entrySet();
}
public void putAll(Map t) {
for (Entry entry : t.entrySet()) {
put(entry.getKey(), entry.getValue());
}
}
public boolean containsValue(Object value) {
return map.containsValue(value);
}
private synchronized CountDownLatch latchFor(K key) {
CountDownLatch latch = latches.get(key);
if (latch == null) {
latch = new CountDownLatch(1);
latches.put(key, latch);
}
return latch;
}
}