Uso de Guava para el almacenamiento en memoria caché seguro de alto rendimiento

Question

Estoy tratando de implementar un almacenamiento en caché seguro de subprocesos de alto rendimiento. Aquí está el código que he implementado. No quiero ninguna informática bajo demanda. ¿Puedo usar cache.asMap() y recuperar el valor de forma segura? Incluso si la memoria caché está configurada para tener SoftValues?

import java.io.IOException; 
    import java.util.concurrent.ConcurrentMap; 
    import java.util.concurrent.ExecutionException; 
    import java.util.concurrent.TimeUnit; 
    import java.util.concurrent.TimeoutException; 

    import com.google.common.cache.Cache; 
    import com.google.common.cache.CacheBuilder; 

    public class MemoryCache { 

    private static MemoryCache instance; 
    private Cache<String, Object> cache; 

    private MemoryCache(int concurrencyLevel, int expiration, int size) throws IOException { 

     cache = CacheBuilder.newBuilder().concurrencyLevel(concurrencyLevel).maximumSize(size).softValues() 
      .expireAfterWrite(expiration, TimeUnit.SECONDS).build(); 
    } 

    static public synchronized MemoryCache getInstance() throws IOException { 
     if (instance == null) { 
       instance = new MemoryCache(10000, 3600,1000000); 
     } 
     return instance; 
    } 

    public Object get(String key) { 
     ConcurrentMap<String,Object> map =cache.asMap(); 
     return map.get(key); 
    } 

    public void put(String key, Object obj) { 
     cache.put(key, obj); 
    } 
    } 

Answer 1

guayaba colaborador aquí:

Sí, que se ve muy bien, aunque no estoy seguro de lo que es el punto de envolver la caché en otro objeto. (Además, Cache.getIfPresent(key) es totalmente equivalente a Cache.asMap().get(key).)

Answer 2

Si desea un alto rendimiento, ¿por qué no instancia el Caché estáticamente en lugar de usar un getInstance sincronizado()?