In Java Concurrency In Practice di Brian Goetz

Question

Java Concurrency In Practice di Brian Goetz fornisce un esempio di efficiente cache scalabile per uso simultaneo. Ecco il codice per la classe:

public class Memoizer<A, V> implements Computable<A, V> { 
    private final ConcurrentMap<A, Future<V>> cache 
     = new ConcurrentHashMap<A, Future<V>>(); 
    private final Computable<A, V> c; 

    public Memoizer(Computable<A, V> c) { this.c = c; } 

    public V compute(final A arg) throws InterruptedException { 
     while (true) { 
      Future<V> f = cache.get(arg); 
      if (f == null) { 
       Callable<V> eval = new Callable<V>() { 
        public V call() throws InterruptedException { 
         return c.compute(arg); 
        } 
       }; 
       FutureTask<V> ft = new FutureTask<V>(eval); 
       f = cache.putIfAbsent(arg, ft); 
       if (f == null) { f = ft; ft.run(); } 
      } 
      try { 
       return f.get(); 
      } catch (CancellationException e) { 
       cache.remove(arg, f); 
      } catch (ExecutionException e) { 
       throw launderThrowable(e.getCause()); 
      } 
     } 
    } } 

Probabilmente una domanda stupida, ma nessuna indicazione qualcuno mi mostrano l'utilizzo concomitante di questa classe? Come in una main?

Cheers, Agata

Answer 1

Ecco un esempio che calcola fattoriali:

public static void main(String[] args) throws Exception { 

    //create a memoizer that performs factorials 
    final Memoizer<Integer, Integer> memo = new Memoizer<Integer, Integer> (new Computable<Integer, Integer>() { 
     @Override 
     public Integer compute(Integer a) { 
      int result = 1 ; 
      for(int i = 1 ; i < a ; i++){ 
       result = result*i; 
      } 
      return result; 
     } 
    }); 

    //now call the memoizer 
    System.out.println(memo.compute(10)); 


    //call it with 10 threads concurrently 
    ExecutorService exec = Executors.newFixedThreadPool(10); 
    ExecutorCompletionService<Integer> compService = new ExecutorCompletionService<Integer>(exec); 
    for(int i = 0 ; i < 15 ; i++){ 
     compService.submit(new Callable<Integer>(){ 
      @Override 
      public Integer call() throws Exception { 
       return memo.compute(5); 
      } 
     }); 
    } 
    exec.shutdown(); 
    for(int i = 0 ; i < 15 ; i++){ 
     System.out.println(compService.take().get()); 
    } 
} 

Quindi, se due thread cercano di calcolare la stessa fattoriale esattamente allo stesso tempo, solo uno di loro eseguirà effettivamente il calcolo, perché putIfAbsent è thread-safe. Il secondo thread otterrà semplicemente il futuro che è stato inserito nella mappa dal primo thread e aspetta che finisca.

Answer 2

potrei immaginare qualcosa di simile:

class PrimeDetector implements Computable<BigInteger, Boolean> { 
    public Boolean compute(BigInteger number) { 
    // detect whether the number is prime and return true if it is 
    } 
} 

Memoizer<BigInteger, Boolean> primeMemoizer = 
     new Memoizer<BigInteger, BigInteger[]>(new PrimeDetector()); 
boolean isPrime = primeMemoizer.compute(
     new BigInteger("5625945193217348954671586615478165774647538956473535")); 
...