Auf der Suche nach einem einfachen Java-In-Memory-Cache [geschlossen]

Ich suche nach einem einfachen Java-In-Memory-Cache mit guter Parallelität (daher ist LinkedHashMap nicht gut genug), der regelmäßig auf die Festplatte serialisiert werden kann.

Eine Funktion, die ich brauche, die sich jedoch als schwer zu finden erwiesen hat, ist die Möglichkeit, ein Objekt zu "betrachten". Damit meine ich das Abrufen eines Objekts aus dem Cache, ohne dass der Cache das Objekt länger als sonst festhält.

Update: Eine zusätzliche Anforderung, die ich nicht erwähnt habe, ist, dass ich in der Lage sein muss, die zwischengespeicherten Objekte (sie enthalten Float-Arrays) direkt zu ändern.

Kann jemand irgendwelche Empfehlungen geben?

Da diese Frage ursprünglich gestellt wurde, enthält die Guava-Bibliothek von Google jetzt einen leistungsstarken und flexiblen Cache. Ich würde empfehlen, dies zu verwenden.

Ehcache ist eine ziemlich gute Lösung dafür und bietet eine Möglichkeit, einen Blick darauf zu werfen ( getQuiet () ist die Methode), sodass der Leerlaufzeitstempel nicht aktualisiert wird. Intern wird Ehcache mit einer Reihe von Karten implementiert, ähnlich wie ConcurrentHashMap, sodass es ähnliche Vorteile für die Parallelität bietet.

Wenn Sie etwas Einfaches brauchen, würde dies zur Rechnung passen?

Map<K, V> myCache = Collections.synchronizedMap(new WeakHashMap<K, V>());

Es wird nicht auf der Festplatte gespeichert, aber Sie sagten, Sie wollten einfach ...

Links:

• Collections.synchronizedMap
• WeakHashMap

(Wie Adam kommentierte, hat das Synchronisieren einer Karte einen Leistungseinbruch. Nicht zu sagen, dass die Idee keine Haare hat, aber als schnelle und schmutzige Lösung ausreichen würde.)

Eine weitere Option für einen speicherinternen Java-Cache ist cache2k . Die In-Memory-Leistung ist EHCache und Google Guava überlegen (siehe Seite mit den Cache2k-Benchmarks) .

Das Verwendungsmuster ähnelt anderen Caches. Hier ist ein Beispiel:

Cache<String,String> cache = new Cache2kBuilder<String, String>() {}
  .expireAfterWrite(5, TimeUnit.MINUTES)    // expire/refresh after 5 minutes
  .resilienceDuration(30, TimeUnit.SECONDS) // cope with at most 30 seconds
                                          // outage before propagating 
                                          // exceptions
  .refreshAhead(true)                       // keep fresh when expiring
  .loader(new CacheLoader<String, String>() {
    @Override
    public String load(final String key) throws Exception {
      return ....;
    }
  })
  .build();
String val = cache.peek("something");
cache.put("something", "hello");
val = cache.get("something");

Wenn Sie Google Guava als Abhängigkeit haben, ist das Ausprobieren des Guaven-Cache möglicherweise eine gute Alternative.

Sie können einfach imcache verwenden . Ein Beispielcode ist unten.

void example(){
    Cache<Integer,Integer> cache = CacheBuilder.heapCache().
    cacheLoader(new CacheLoader<Integer, Integer>() {
        public Integer load(Integer key) {
            return null;
        }
    }).capacity(10000).build(); 
}

Versuche dies:

import java.util.*;

public class SimpleCacheManager {

    private static SimpleCacheManager instance;
    private static Object monitor = new Object();
    private Map<String, Object> cache = Collections.synchronizedMap(new HashMap<String, Object>());

    private SimpleCacheManager() {
    }

    public void put(String cacheKey, Object value) {
        cache.put(cacheKey, value);
    }

    public Object get(String cacheKey) {
        return cache.get(cacheKey);
    }

    public void clear(String cacheKey) {
        cache.put(cacheKey, null);
    }

    public void clear() {
        cache.clear();
    }

    public static SimpleCacheManager getInstance() {
        if (instance == null) {
            synchronized (monitor) {
                if (instance == null) {
                    instance = new SimpleCacheManager();
                }
            }
        }
        return instance;
    }

}

Versuchen Sie es @Cacheableunter jcabi-Aspekten . Mit einer einzigen Anmerkung können Sie das gesamte Methodenergebnis im Speicher zwischenspeichern:

public class Resource {
  @Cacheable(lifetime = 5, unit = TimeUnit.SECONDS)
  public String load(URL url) {
    return url.openConnection().getContent();
  }
}

Lesen Sie auch diesen Artikel: http://www.yegor256.com/2014/08/03/cacheable-java-annotation.html

Wie wäre es damit: https://commons.apache.org/proper/commons-jcs/ (auf neue Adresse aktualisiert, da JCS jetzt in Apache Commons ist)

Versuchen Sie es mit Ehcache ? Sie können damit Ihre eigenen Caching-Ablaufalgorithmen einbinden, um Ihre Peek-Funktionalität zu steuern.

Sie können auf Festplatte, Datenbank, in einem Cluster usw. serialisieren.