Utilizzo di Guava per la memorizzazione nella cache sicura da threading ad alte prestazioni

Question

Sto tentando di implementare una memorizzazione nella cache thread-safe ad alte prestazioni. Ecco il codice che ho implementato. Non voglio alcun calcolo on demand. Posso usare cache.asMap() e recuperare il valore in sicurezza? Anche se la cache è impostata per avere 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

Guava collaboratore qui:

Sì, che sembra più che bene, anche se non sono sicuro di quello che il punto è di avvolgere la cache in un altro oggetto. (Inoltre, è completamente equivalente a Cache.asMap().get(key).)

Answer 2

Se si desidera prestazioni elevate, perché non si instaza la cache in modo statico anziché utilizzare getInstance() sincronizzato?