Java Simple nom de la base de serrures?

Toutes ces réponses je vois sont trop compliqués. Pourquoi ne pas simplement utiliser:

public void executeInNamedLock(String lockName, Runnable runnable) {
  synchronized(lockName.intern()) {
    runnable.run();
  }
}

Le point clé est la méthode intern: il s'assure que la Chaîne de caractères retournée est d'un unique objet, et donc il peut être utilisé en tant que machine virtuelle-exemple à l'échelle de mutex. Tous les internés les Chaînes sont tenues dans un pool mondial, de sorte que votre statique de cache vous parliez dans votre question initiale. Ne vous inquiétez pas à propos de memleaks; ces chaînes seront gc ed si aucun autre thread référence. Notez cependant que, jusqu'à et y compris Java6 cette piscine est gardé dans PermGen space au lieu de le tas, alors vous pourriez avoir à augmenter.

Il y a un problème, par contre si un autre code dans votre vm verrous sur la même chaîne pour des raisons complètement différentes, mais une) c'est très peu probable, et b) vous pouvez contourner ce problème en introduisant des espaces de noms, par exemple executeInNamedLock(this.getClass().getName() + "_" + myLockName);

//pool of names that are being locked
HashSet<String> pool = new HashSet<String>(); 

lock(name)
    synchronized(pool)
        while(pool.contains(name)) //already being locked
            pool.wait();           //wait for release
        pool.add(name);            //I lock it

unlock(name)
    synchronized(pool)
        pool.remove(name);
        pool.notifyAll();

De verrouillage sur quelque chose comme un nom d'utilisateur, en mémoire Locks dans une carte peut-être un peu baveur. Comme alternative, vous pouvez rechercher à l'aide de WeakReferences avec WeakHashMap pour créer des objets mutex qui peuvent être des ordures collectées lorsque rien n'y fait référence. Cela vous évite de faire n'importe quel manuel de référence de comptage pour libérer de la mémoire.

Vous pouvez trouver une mise en œuvre ici. Notez que si vous faites fréquemment des recherches sur la carte, vous risquez de rencontrer les problèmes de conflit d'acquérir le mutex.

Basé sur la réponse de McDowell et de sa classe IdMutexProvider, j'ai écrit à la classe générique LockMap qui utilise WeakHashMap pour stocker des objets de verrou. LockMap.get() peut être utilisé pour récupérer un objet de verrouillage pour une clé, qui peut ensuite être utilisé avec Java synchronized (...) déclaration d'appliquer un verrou. Serrure utilisé les objets sont automatiquement libérés lors de la collecte des ordures.

import java.lang.ref.WeakReference;
import java.util.WeakHashMap;
//A map that creates and stores lock objects for arbitrary keys values.
//Lock objects which are no longer referenced are automatically released during garbage collection.
//Author: Christian d'Heureuse, www.source-code.biz
//Based on IdMutexProvider by McDowell, http://illegalargumentexception.blogspot.ch/2008/04/java-synchronizing-on-transient-id.html
//See also https://stackoverflow.com/questions/5639870/simple-java-name-based-locks
public class LockMap<KEY> {
private WeakHashMap<KeyWrapper<KEY>,WeakReference<KeyWrapper<KEY>>> map;
public LockMap() {
map = new WeakHashMap<KeyWrapper<KEY>,WeakReference<KeyWrapper<KEY>>>(); }
//Returns a lock object for the specified key.
public synchronized Object get (KEY key) {
if (key == null) {
throw new NullPointerException(); }
KeyWrapper<KEY> newKeyWrapper = new KeyWrapper<KEY>(key);
WeakReference<KeyWrapper<KEY>> ref = map.get(newKeyWrapper);
KeyWrapper<KEY> oldKeyWrapper = (ref == null) ? null : ref.get();
if (oldKeyWrapper != null) {
return oldKeyWrapper; }
map.put(newKeyWrapper, new WeakReference<KeyWrapper<KEY>>(newKeyWrapper));
return newKeyWrapper; }
//Returns the number of used entries in the map.
public synchronized int size() {
return map.size(); }
//KeyWrapper wraps a key value and is used in three ways:
//- as the key for the internal WeakHashMap
//- as the value for the internal WeakHashMap, additionally wrapped in a WeakReference
//- as the lock object associated to the key
private static class KeyWrapper<KEY> {
private KEY key;
private int hashCode;
public KeyWrapper (KEY key) {
this.key = key;
hashCode = key.hashCode(); }
public boolean equals (Object obj) {
if (obj == this) {
return true; }
if (obj instanceof KeyWrapper) {
return ((KeyWrapper)obj).key.equals(key); }
return false; }
public int hashCode() {
return hashCode; }}
} //end class LockMap

Exemple d'utilisation de la LockMap classe:

private static LockMap<String> lockMap = new LockMap<String>();
synchronized (lockMap.get(name)) {
... 
}

Un programme de test simple pour le LockMap classe:

public static Object lock1;
public static Object lock2;
public static void main (String[] args) throws Exception {
System.out.println("TestLockMap Started");
LockMap<Integer> map = new LockMap<Integer>();
lock1 = map.get(1);
lock2 = map.get(2);
if (lock2 == lock1) {
throw new Error(); }
Object lock1b = map.get(1);
if (lock1b != lock1) {
throw new Error(); }
if (map.size() != 2) {
throw new Error(); }
for (int i=0; i<10000000; i++) {
map.get(i); }
System.out.println("Size before gc: " + map.size());   //result varies, e.g. 4425760
System.gc();
Thread.sleep(1000);
if (map.size() != 2) {
System.out.println("Size after gc should be 2 but is " + map.size()); }
System.out.println("TestLockMap completed"); }

Si quelqu'un connaît une meilleure façon de tester automatiquement la LockMap classe, s'il vous plaît écrire un commentaire.

2 ans plus tard mais j'ai été la recherche d'un simple nommé casier solution et suis tombé sur ce, a été utile, mais j'avais besoin d'une simple réponse, donc en dessous de ce que je suis venu avec.

Simple de verrouillage sous quelque nom et relâchez à nouveau sous le même nom.

private void doTask(){
locker.acquireLock(name);
try{
//do stuff locked under the name
}finally{
locker.releaseLock(name);
}
}

Voici le code:

public class NamedLocker {
private ConcurrentMap<String, Semaphore> synchSemaphores = new ConcurrentHashMap<String, Semaphore>();
private int permits = 1;
public NamedLocker(){
this(1);
}
public NamedLocker(int permits){
this.permits = permits;
}
public void acquireLock(String... key){
Semaphore tempS = new Semaphore(permits, true);
Semaphore s = synchSemaphores.putIfAbsent(Arrays.toString(key), tempS);
if(s == null){
s = tempS;
}
s.acquireUninterruptibly();
}
public void releaseLock(String... key){
Semaphore s = synchSemaphores.get(Arrays.toString(key));
if(s != null){
s.release();
}
}
}

Après une certaine déception qu'il n'existe pas de niveau de langue, de soutien ou de simples Goyave/Commons classe pour nommé les verrous,

C'est ce que je me suis installé à:

ConcurrentMap<String, Object> locks = new ConcurrentHashMap<>();
Object getLock(String name) {
Object lock = locks.get(name);
if (lock == null) {
Object newLock = new Object();
lock = locks.putIfAbsent(name, newLock);
if (lock == null) {
lock = newLock;
}
}
return lock;
}
void somethingThatNeedsNamedLocks(String name) {
synchronized(getLock(name)) {
//some operations mutually exclusive per each name
}
}

Ici que j'ai réalisé: peu de code réutilisable avec aucune dépendance de bibliothèque, de manière atomique de l'acquisition du verrou de l'objet, de ne pas polluer le mondial de l'internement des objets string, pas de bas-niveau de l'informer/attendre le chaos et pas de try-catch-finally mess.

Mémoire considération

Souvent, la synchronisation nécessaire pour chaque clé est de courte durée. Garder autour relâché les touches peuvent conduire à des abus de la mémoire des déchets, le rendant non-viable.

Voici une implémentation de ne pas garder en interne autour relâché les touches.

import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.CountDownLatch;
public class KeyedMutexes<K> {
private final ConcurrentMap<K, CountDownLatch> key2Mutex = new ConcurrentHashMap<>();
public void lock(K key) throws InterruptedException {
final CountDownLatch ourLock = new CountDownLatch(1);
for (;;) {
CountDownLatch theirLock = key2Mutex.putIfAbsent(key, ourLock);
if (theirLock == null) {
return;
}
theirLock.await();
}
}
public void unlock(K key) {
key2Mutex.remove(key).countDown();
}
}

Réentrée, et d'autres cloches et de sifflets

Si l'on veut re-participant de verrouillage de la sémantique, ils peuvent prolonger la ci-dessus en les enveloppant l'objet mutex dans une classe qui conserve la trace de l'verrouillage fil et verrouillé comte.

par exemple:

private static class Lock {
final CountDownLatch mutex = new CountDownLatch(1);
final long threadId = Thread.currentThread().getId();
int lockedCount = 1;
}

Si l'on veut lock() pour retourner un objet pour en faire des versions plus facile et plus sûr, c'est aussi une possibilité.

Mettre tous ensemble, voici de quoi il pourrait ressembler:

public class KeyedReentrantLocks<K> {
private final ConcurrentMap<K, KeyedLock> key2Lock = new ConcurrentHashMap<>();
public KeyedLock acquire(K key) throws InterruptedException {
final KeyedLock ourLock = new KeyedLock() {
@Override
public void close() {
if (Thread.currentThread().getId() != threadId) {
throw new IllegalStateException("wrong thread");
}
if (--lockedCount == 0) {
key2Lock.remove(key);
mutex.countDown();
}
}
};
for (;;) {
KeyedLock theirLock = key2Lock.putIfAbsent(key, ourLock);
if (theirLock == null) {
return ourLock;
}
if (theirLock.threadId == Thread.currentThread().getId()) {
theirLock.lockedCount++;
return theirLock;
}
theirLock.mutex.await();
}
}
public static abstract class KeyedLock implements AutoCloseable {
protected final CountDownLatch mutex = new CountDownLatch(1);
protected final long threadId = Thread.currentThread().getId();
protected int lockedCount = 1;
@Override
public abstract void close();
}
}

Et voici comment on pourrait l'utiliser:

try (KeyedLock lock = locks.acquire("SomeName")) {
//do something critical here
}

En réponse à la suggestion de l'utilisation des nouvelles Cartographe().makeComputingMap()...

Cartographe().makeComputingMap() est déconseillé pour des raisons de sécurité. Le successeur est CacheBuilder. Avec la faiblesse de clés/valeurs appliquées à CacheBuilder, nous sommes tellement proche d'une solution.

Le problème, c'est une note dans CacheBuilder.weakKeys():

when this method is used, the resulting cache will use identity (==) comparison to determine equality of keys. 

Ce qui rend impossible d'en sélectionner un existant de verrouillage par chaîne de valeur. Erg.

J'ai créé un tokenProvider basé sur la IdMutexProvider de McDowell.
Le gestionnaire utilise un WeakHashMap qui prend soin de nettoyer inutilisés serrures.

TokenManager:

/**
* Token provider used to get a {@link Mutex} object which is used to get exclusive access to a given TOKEN.
* Because WeakHashMap is internally used, Mutex administration is automatically cleaned up when
* the Mutex is no longer is use by any thread.
*
* <pre>
* Usage:
* private final TokenMutexProvider&lt;String&gt; myTokenProvider = new TokenMutexProvider&lt;String&gt;();
*
* Mutex mutex = myTokenProvider.getMutex("123456");
* synchronized (mutex) {
*  //your code here
* }
* </pre>
*
* Class inspired by McDowell.
* url: http://illegalargumentexception.blogspot.nl/2008/04/java-synchronizing-on-transient-id.html
*
* @param <TOKEN> type of token. It is important that the equals method of that Object return true
* for objects of different instances but with the same 'identity'. (see {@link WeakHashMap}).<br>
* E.g.
* <pre>
*  String key1 = "1";
*  String key1b = new String("1");
*  key1.equals(key1b) == true;
*
*  or
*  Integer key1 = 1;
*  Integer key1b = new Integer(1);
*  key1.equals(key1b) == true;
* </pre>
*/
public class TokenMutexProvider<TOKEN> {
private final Map<Mutex, WeakReference<Mutex>> mutexMap = new WeakHashMap<Mutex, WeakReference<Mutex>>();
/**
* Get a {@link Mutex} for the given (non-null) token.
*/
public Mutex getMutex(TOKEN token) {
if (token==null) {
throw new NullPointerException();
}
Mutex key = new MutexImpl(token);
synchronized (mutexMap) {
WeakReference<Mutex> ref = mutexMap.get(key);
if (ref==null) {
mutexMap.put(key, new WeakReference<Mutex>(key));
return key;
}
Mutex mutex = ref.get();
if (mutex==null) {
mutexMap.put(key, new WeakReference<Mutex>(key));
return key;
}
return mutex;
}
}
public int size() {
synchronized (mutexMap) {
return mutexMap.size();
}
}
/**
* Mutex for acquiring exclusive access to a token.
*/
public static interface Mutex {}
private class MutexImpl implements Mutex {
private final TOKEN token;
protected MutexImpl(TOKEN token) {
this.token = token;
}
@Override
public boolean equals(Object other) {
if (other==null) {
return false;
}
if (getClass()==other.getClass()) {
TOKEN otherToken = ((MutexImpl)other).token;
return token.equals(otherToken);
}
return false;
}
@Override
public int hashCode() {
return token.hashCode();
}
}
}

Utilisation:

private final TokenMutexManager<String> myTokenManager = new TokenMutexManager<String>();
Mutex mutex = myTokenManager.getMutex("UUID_123456");
synchronized(mutex) {
//your code here
}

ou plutôt l'utilisation d'Entiers?

private final TokenMutexManager<Integer> myTokenManager = new TokenMutexManager<Integer>();
Mutex mutex = myTokenManager.getMutex(123456);
synchronized(mutex) {
//your code here
}

Ici est une simple solution optimisée qui traite de la suppression de utilisé des verrous également, mais avec une surcharge de la synchronisation de la Carte:

public class NamedLock {
private Map<String, ReentrantLock> lockMap;
public NamedLock() {
lockMap = new HashMap<>();
}
public void lock(String... name) {
ReentrantLock newLock = new ReentrantLock(true);
ReentrantLock lock;
synchronized (lockMap) {
lock = Optional.ofNullable(lockMap.putIfAbsent(Arrays.toString(name), newLock)).orElse(newLock);
}
lock.lock();
}
public void unlock(String... name) {
ReentrantLock lock = lockMap.get(Arrays.toString(name));
synchronized (lockMap) {
if (!lock.hasQueuedThreads()) {
lockMap.remove(name);
}
}
lock.unlock();
}    

}

TreeMap parce que dans la table de hachage de taille intérieure de la matrice ne peut qu'augmenter

public class Locker<T> {
private final Object lock = new Object();
private final Map<T, Value> map = new TreeMap<T, Value>();
public Value<T> lock(T id) {
Value r;
synchronized (lock) {
if (!map.containsKey(id)) {
Value value = new Value();
value.id = id;
value.count = 0;
value.lock = new ReentrantLock();
map.put(id, value);
}
r = map.get(id);
r.count++;
}
r.lock.lock();
return r;
}
public void unlock(Value<T> r) {
r.lock.unlock();
synchronized (lock) {
r.count--;
if (r.count == 0)
map.remove(r.id);
}
}
public static class Value<T> {
private Lock lock;
private long count;
private T id;
}
}