具有过期键的Java基于时间的映射/缓存

小开

最佳答案

是的。谷歌Collections，或番石榴，就像它的名字一样，现在有一个叫做制图师的东西，它可以做到这一点。

ConcurrentMap<Key, Graph> graphs = new MapMaker()
.concurrencyLevel(4)
.softKeys()
.weakValues()
.maximumSize(10000)
.expiration(10, TimeUnit.MINUTES)
.makeComputingMap(
new Function<Key, Graph>() {
public Graph apply(Key key) {
return createExpensiveGraph(key);
}
});

更新:

由于guava 10.0(发布于2011年9月28日)，许多这些MapMaker方法已经弃用，转而支持新的CacheBuilder:

LoadingCache<Key, Graph> graphs = CacheBuilder.newBuilder()
.maximumSize(10000)
.expireAfterWrite(10, TimeUnit.MINUTES)
.build(
new CacheLoader<Key, Graph>() {
public Graph load(Key key) throws AnyException {
return createExpensiveGraph(key);
}
});

小开

谷歌集合(guava)有制图师，你可以在其中设置时间限制(过期)，你可以使用软引用或弱引用，因为你选择使用工厂方法来创建你选择的实例。

小开

听起来ehcache对你想要的东西来说有点过头了，但是请注意它不需要外部配置文件。

将配置移动到声明性配置文件中通常是一个好主意(这样当新安装需要不同的过期时间时，您就不需要重新编译)，但这根本不是必需的，您仍然可以以编程方式配置它。http://www.ehcache.org/documentation/user-guide/configuration

小开

你可以尝试过期地图 http://www.java2s.com/Code/Java/Collections-Data-Structure/ExpiringMap.htm a类从Apache MINA项目

小开

Apache Commons为Map过期条目提供了装饰器:PassiveExpiringMap

另外，小心点，这不是同步的。

小开

你可以尝试自到期哈希映射的我的实现。这个实现不使用线程来删除过期的条目，而是使用DelayQueue，在每次操作时自动清理。

小开

如果有人需要一个简单的东西，下面是一个简单的键到期集。它可以很容易地转换为地图。

public class CacheSet<K> {
public static final int TIME_OUT = 86400 * 1000;


LinkedHashMap<K, Hit> linkedHashMap = new LinkedHashMap<K, Hit>() {
@Override
protected boolean removeEldestEntry(Map.Entry<K, Hit> eldest) {
final long time = System.currentTimeMillis();
if( time - eldest.getValue().time > TIME_OUT) {
Iterator<Hit> i = values().iterator();


i.next();
do {
i.remove();
} while( i.hasNext() && time - i.next().time > TIME_OUT );
}
return false;
}
};




public boolean putIfNotExists(K key) {
Hit value = linkedHashMap.get(key);
if( value != null ) {
return false;
}


linkedHashMap.put(key, new Hit());
return true;
}


private static class Hit {
final long time;




Hit() {
this.time = System.currentTimeMillis();
}
}
}

小开

通常，缓存应该将对象保存一段时间，并在一段时间后将它们公开。拿东西的好时机是什么取决于用例。我希望这件事很简单，没有线程或调度器。这种方法对我很有效。与__abc0不同，对象被保证在最短时间内可用。然而，它们不会停留在内存直到太阳变成红巨星中。

作为使用示例，请考虑一个响应缓慢的系统，它应该能够检查一个请求是否最近已经完成，并且在这种情况下，即使繁忙的用户多次按下按钮，也不会执行两次所请求的操作。但是，如果一段时间后要求进行相同的操作，则应再次执行。

class Cache<T> {
long avg, count, created, max, min;
Map<T, Long> map = new HashMap<T, Long>();


/**
* @param min   minimal time [ns] to hold an object
* @param max   maximal time [ns] to hold an object
*/
Cache(long min, long max) {
created = System.nanoTime();
this.min = min;
this.max = max;
avg = (min + max) / 2;
}


boolean add(T e) {
boolean result = map.put(e, Long.valueOf(System.nanoTime())) != null;
onAccess();
return result;
}


boolean contains(Object o) {
boolean result = map.containsKey(o);
onAccess();
return result;
}


private void onAccess() {
count++;
long now = System.nanoTime();
for (Iterator<Entry<T, Long>> it = map.entrySet().iterator(); it.hasNext();) {
long t = it.next().getValue();
if (now > t + min && (now > t + max || now + (now - created) / count > t + avg)) {
it.remove();
}
}
}
}

小开

这是一个示例实现，我为相同的需求和并发工作得很好。可能对某人有用。

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;


/**
*
* @author Vivekananthan M
*
* @param <K>
* @param <V>
*/
public class WeakConcurrentHashMap<K, V> extends ConcurrentHashMap<K, V> {


private static final long serialVersionUID = 1L;


private Map<K, Long> timeMap = new ConcurrentHashMap<K, Long>();
private long expiryInMillis = 1000;
private static final SimpleDateFormat sdf = new SimpleDateFormat("hh:mm:ss:SSS");


public WeakConcurrentHashMap() {
initialize();
}


public WeakConcurrentHashMap(long expiryInMillis) {
this.expiryInMillis = expiryInMillis;
initialize();
}


void initialize() {
new CleanerThread().start();
}


@Override
public V put(K key, V value) {
Date date = new Date();
timeMap.put(key, date.getTime());
System.out.println("Inserting : " + sdf.format(date) + " : " + key + " : " + value);
V returnVal = super.put(key, value);
return returnVal;
}


@Override
public void putAll(Map<? extends K, ? extends V> m) {
for (K key : m.keySet()) {
put(key, m.get(key));
}
}


@Override
public V putIfAbsent(K key, V value) {
if (!containsKey(key))
return put(key, value);
else
return get(key);
}


class CleanerThread extends Thread {
@Override
public void run() {
System.out.println("Initiating Cleaner Thread..");
while (true) {
cleanMap();
try {
Thread.sleep(expiryInMillis / 2);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}


private void cleanMap() {
long currentTime = new Date().getTime();
for (K key : timeMap.keySet()) {
if (currentTime > (timeMap.get(key) + expiryInMillis)) {
V value = remove(key);
timeMap.remove(key);
System.out.println("Removing : " + sdf.format(new Date()) + " : " + key + " : " + value);
}
}
}
}
}

Git Repo Link(带有监听器实现)

https://github.com/vivekjustthink/WeakConcurrentHashMap

干杯! !