Java: Synchronisation auf primitive?

Können Sie versuchen, etwas mit einem ReentrantLock, so dass du eine Map<Long,Lock>. Jetzt nach lock.release() können Sie testen, zu sperren.hasQueuedThreads(). Wenn das false zurückgibt, können Sie entfernen Sie Sie aus der Karte.

Beginnen mit:

1. Können Sie nicht einsperren, auf eine primitive und
2. Die sperren nicht auf eine Lange, es sei denn, Sie sind vorsichtig, wie Sie Sie bauen. Long-Werte erstellt durch autoboxing oder Lang.valueOf() in einen bestimmten Bereich sind garantiert die gleichen in der gesamten JVM, das heißt, andere threads werden konnte Verriegelung auf exakt das gleiche Lange, - Objekt und geben Sie cross-talk. Dies kann eine subtile concurrency bug (ähnlich der sperren auf intern ' ed strings).

Du redest hier über einen lock-striping setup. Das eine Ende des Kontinuums ist eine einzige Riesen-Schloss für alle ids, die ist einfach und sicher, aber nicht gleichzeitige. Das andere Ende wird ein Schloss pro-id, die ist leicht (um einige Grad) und sicher und sehr Auger aber könnte erfordern eine große Anzahl von "lock-in der Lage Objekte" im Speicher (wenn du nicht schon eine hast). Irgendwo in der Mitte ist die Idee der Schaffung einer Sperre für eine Reihe von ids - diese Option ermöglicht die Einstellung der Parallelität auf der Grundlage Ihrer Umgebung und Entscheidungen zu treffen, über Kompromisse zwischen Speicher und Parallelität.

ConcurrentHashMap kann verwendet werden, um dies zu erreichen, als CHM-aus intern der Segmente liegen (sub-maps) und es gibt einen lock-pro segment. Dies gibt Ihnen die Parallelität gleich der Anzahl von Segmenten (standardmäßig auf 16, ist aber konfigurierbar).

Gibt es eine Reihe von anderen möglichen Lösungen für die Partitionierung des ID-Raums und erzeugt Sätze von sperren, aber Sie sind Recht empfindlich zu sein die clean-up und memory-leak-Probleme - kümmern, die unter Beibehaltung der Parallelität ist ein schwieriges Geschäft. Benötigen Sie irgendeine Art von Referenz zählt auf jeden sperren und zu verwalten, die Räumung des alten Schlössern sorgfältig zu vermeiden, wenn eine Sperre, die in den Prozess der Arbeit gesperrt. Wenn Sie diesen Weg gehen, verwenden Sie ReentrantLock oder ReentrantReadWriteLock (und nicht synchronisierten Objekte) wie können Sie explizit verwalten das Schloss als ein Objekt und verwenden Sie die zusätzliche Methoden zur Verfügung.

Gibt es auch einige Sachen auf dieser und StripedMap Beispiel in Java Concurrency in Practice Abschnitt 11.4.3.

Wäre es nicht genug, um eine SynchronizedHashMap oder Sammlungen.synchronizedMap(Map m) aus java.util.concurrent-Paket anstelle des einfachen HashMap, wo Aufrufe zum abrufen und einfügen sind nicht synchronisiert?

etwas wie:

Map<Long,Object> myMap = new HashMap<Long,Object>();
Map<Long,Object> mySyncedMap=Collections.synchronizedMap(myMap);

Dies ist, wo ich mit einem canonicalizing Karte, die braucht Ihr long input und gibt einen kanonischen Long Objekt, das Sie dann verwenden können, um zu synchronisieren. Ich habe geschrieben über canonicalizing Karten hier; ersetzen Sie einfach String durch Long (und um Ihr Leben leichter machen, lassen Sie es nehmen Sie eine long als parameter).

Sobald Sie die canonicalizing Karte, Sie würden schreiben Ihr Schloss bewachten code wie folgt:

Long lockObject = canonMap.get(id);
synchronized (lockObject)
{
    //stuff
}

Den canonicalizing Karte würde sicherstellen, dass die gleichen lockObject zurückgegeben wird, für die gleiche ID. Wenn es keine aktiven Referenzen zu lockObject sind, werden Sie für die garbage collection freigegeben, so dass Sie nicht füllen Sie den Speicher mit unnötigen Objekten.

Ich vielleicht zu spät zum Spiel, aber diese Lösung ist nicht undicht Speicher und Sie müssen nicht daran denken, zu tun-lock-frei:

Synchronizer<AccountId> synchronizer = new Synchronizer();

...

//first thread - acquires "lock" for accountId accAAA

synchronizer.synchronizeOn(accountId("accAAA"), () -> {
    long balance = loadBalance("accAAA")
    if (balance > 10_000) {
        decrementBalance("accAAA", 10_000)
    }
})

...

//second thread - is blocked while first thread runs (as it uses the same "lock" for accountId accAAA)

synchronizer.synchronizeOn(accountId("accAAA"), () -> {
    long balance = loadBalance("accAAA")
    if (balance > 2_000) {
        decrementBalance("accAAA", 2_000)
    }
})

...

//third thread - won't be blocked by previous threads (as it is for a different accountId)

synchronizer.synchronizeOn(accountId("accXYZ"), () -> {
    long balance = loadBalance("accXYZ")
    if (balance > 3_500) {
        decrementBalance("accXYZ", 3_500)
    }
})

es zu verwenden, fügen Sie einfach eine Abhängigkeit:

compile 'com.github.matejtymes:javafixes:1.3.0'