Szukam prostej pamięci podręcznej Java w pamięci [zamknięta]

Szukam prostej pamięci podręcznej Java, która ma dobrą współbieżność (więc LinkedHashMap nie jest wystarczająco dobra) i którą można okresowo serializować na dysk.

Jedną z funkcji, której potrzebuję, ale która okazała się trudna do znalezienia, jest sposób „zerknięcia” na obiekt. Rozumiem przez to pobranie obiektu z pamięci podręcznej bez powodowania, że ​​pamięć podręczna przetrzymuje obiekt dłużej niż w innym przypadku.

Aktualizacja: Dodatkowym wymaganiem, o którym zapomniałem wspomnieć, jest to, że muszę mieć możliwość modyfikowania obiektów w pamięci podręcznej (zawierają tablice zmiennoprzecinkowe) w miejscu.

Czy ktoś może podać jakieś zalecenia?

Ponieważ pierwotnie zadano to pytanie, biblioteka Google Guava zawiera teraz potężną i elastyczną pamięć podręczną. Poleciłbym używanie tego.

Ehcache jest całkiem dobrym rozwiązaniem na to i ma sposób na zerknięcie ( metodą jest getQuiet () ) w taki sposób, że nie aktualizuje znacznika czasu bezczynności. Wewnętrznie Ehcache jest zaimplementowany z zestawem map, podobnym do ConcurrentHashMap, więc ma podobne korzyści ze współbieżności.

Jeśli potrzebujesz czegoś prostego, czy to pasuje do rachunku?

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

Nie zapisuje się na dysku, ale powiedziałeś, że chcesz prosty ...

Spinki do mankietów:

• Collections.synchronizedMap
• WeakHashMap

(Jak skomentował Adam, synchronizacja mapy ma duży wpływ na wydajność. Nie mówię, że pomysł nie ma włosów, ale wystarczyłby jako szybkie i brudne rozwiązanie.)

Inną opcją dla pamięci podręcznej Java w pamięci jest cache2k . Wydajność w pamięci jest lepsza niż EHCache i Google Guava, zobacz stronę testów porównawczych cache2k .

Wzorzec użycia jest podobny do innych pamięci podręcznych. Oto przykład:

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

Jeśli masz google guava jako zależność, wypróbowanie pamięci podręcznej guawy może być dobrą alternatywą.

Możesz łatwo użyć imcache . Przykładowy kod znajduje się poniżej.

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

Spróbuj tego:

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

}

Wypróbuj @Cacheablez aspektów jcabi . Za pomocą jednej adnotacji można zapisać wyniki całej metody w pamięci podręcznej:

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

Przeczytaj również ten artykuł: http://www.yegor256.com/2014/08/03/cacheable-java-annotation.html

Co powiesz na to: https://commons.apache.org/proper/commons-jcs/ (zaktualizowano do nowego adresu, ponieważ JCS jest teraz w Apache Commons)

Wypróbuj Ehcache ? Umożliwia podłączenie własnych algorytmów wygasania pamięci podręcznej, dzięki czemu można kontrolować funkcjonalność podglądu.

Możesz serializować na dysk, bazę danych, przez klaster itp ...