rosca multitons seguras en Java

Question

Dada la siguiente Multiton:

public class Multiton 
{ 
    private static final Multiton[] instances = new Multiton[...]; 

    private Multiton(...) 
    { 
     //... 
    } 

    public static Multiton getInstance(int which) 
    { 
     if(instances[which] == null) 
     { 
      instances[which] = new Multiton(...); 
     } 

     return instances[which]; 
    } 
} 

¿Cómo podemos mantenerlo hilo de seguridad y perezoso y sin la sincronización costosa del método getInstance() y la polémica de bloqueo doble comprobación? Se menciona una forma efectiva para singletons here pero eso no parece extenderse a multitonos.

Answer 1

Esto le dará proporcionar un mecanismo de almacenamiento multi-hilo para sus Multitons. El único inconveniente es que es posible crear una Multiton que no se utilizará en la llamada putIfAbsent(). La posibilidad es pequeña pero existe. Por supuesto, en la remota posibilidad de que suceda, todavía no causa ningún daño.

En el lado positivo, no se requiere preasignación ni inicialización ni restricciones de tamaño predefinidas.

private static ConcurrentHashMap<Integer, Multiton> instances = new ConcurrentHashMap<Integer, Multiton>(); 

public static Multiton getInstance(int which) 
{ 
    Multiton result = instances.get(which); 

    if (result == null) 
    { 
     Multiton m = new Multiton(...); 
     result = instances.putIfAbsent(which, m); 

     if (result == null) 
      result = m; 
    } 

    return result; 
} 

Answer 2

Se podría utilizar un conjunto de cerraduras, por lo menos a ser capaz de obtener diferentes instancias simultáneamente:

private static final Multiton[] instances = new Multiton[...]; 
private static final Object[] locks = new Object[instances.length]; 

static { 
    for (int i = 0; i < locks.length; i++) { 
     locks[i] = new Object(); 
    } 
} 

private Multiton(...) { 
    //... 
} 

public static Multiton getInstance(int which) { 
    synchronized(locks[which]) { 
     if(instances[which] == null) { 
      instances[which] = new Multiton(...); 
     } 
     return instances[which]; 
    } 
} 

Answer 3

Está buscando AtomicReferenceArray.

public class Multiton { 
    private static final AtomicReferenceArray<Multiton> instances = new AtomicReferenceArray<Multiton>(1000); 

    private Multiton() { 
    } 

    public static Multiton getInstance(int which) { 
    // One there already? 
    Multiton it = instances.get(which); 
    if (it == null) { 
     // Lazy make. 
     Multiton newIt = new Multiton(); 
     // Successful put? 
     if (instances.compareAndSet(which, null, newIt)) { 
     // Yes! 
     it = newIt; 
     } else { 
     // One appeared as if by magic (another thread got there first). 
     it = instances.get(which); 
     } 
    } 

    return it; 
    } 
} 

Answer 4

ACTUALIZACIÓN: con Java 8, puede ser aún más simple:

public class Multiton { 
    private static final ConcurrentMap<String, Multiton> multitons = new ConcurrentHashMap<>(); 

    private final String key; 
    private Multiton(String key) { this.key = key; } 

    public static Multiton getInstance(final String key) { 
     return multitons.computeIfAbsent(key, Multiton::new); 
    } 
} 

Mmm eso es bueno!

---

respuesta original

Esta es una solución que se basa en the Memoizer pattern as described in JCiP. Utiliza un ConcurrentHashMap como una de las otras respuestas, pero en lugar de almacenar las instancias de Multiton directamente, lo que puede conducir a la creación de instancias no utilizadas, almacena el cálculo que conduce a la creación de Multiton. Esa capa adicional resuelve el problema de las instancias no utilizadas.

public class Multiton { 

    private static final ConcurrentMap<Integer, Future<Multiton>> multitons = new ConcurrentHashMap<>(); 
    private static final Callable<Multiton> creator = new Callable<Multiton>() { 
     public Multiton call() { return new Multiton(); } 
    }; 

    private Multiton(Strnig key) {} 

    public static Multiton getInstance(final Integer key) throws InterruptedException, ExecutionException { 
     Future<Multiton> f = multitons.get(key); 
     if (f == null) { 
      FutureTask<Multiton> ft = new FutureTask<>(creator); 
      f = multitons.putIfAbsent(key, ft); 
      if (f == null) { 
       f = ft; 
       ft.run(); 
      } 
     } 
     return f.get(); 
    } 
} 

Answer 5

Con el advenimiento de Java 8 y algunas mejoras en ConcurrentMap y lambdas, ahora es posible implementar un Multiton (y probablemente incluso un Singleton) de una manera mucho más ordenada:

public class Multiton { 
    // Map from the index to the item. 
    private static final ConcurrentMap<Integer, Multiton> multitons = new ConcurrentHashMap<>(); 

    private Multiton() { 
    // Possibly heavy construction. 
    } 

    // Get the instance associated with the specified key. 
    public static Multiton getInstance(final Integer key) throws InterruptedException, ExecutionException { 
    // Already made? 
    Multiton m = multitons.get(key); 
    if (m == null) { 
     // Put it in - only create if still necessary. 
     m = multitons.computeIfAbsent(key, k -> new Multiton()); 
    } 
    return m; 
    } 
} 

Sospecho - a pesar de que me haría sentir incómoda - que getInstance podrían minimizarse aún más a:

// Get the instance associated with the specified key. 
public static Multiton getInstance(final Integer key) throws InterruptedException, ExecutionException { 
    // Put it in - only create if still necessary. 
    return multitons.computeIfAbsent(key, k -> new Multiton()); 
}