Persönliche Notizen. Als ich mich mit der exklusiven Java-Steuerung befasste, fand ich den folgenden Artikel. Java synchronisiert garantiert keine Bestellung. Wie im Artikel erwähnt, garantiert das Sperren mit "synchronisiert" nicht die Freigabereihenfolge, wenn mehrere Sperren gleichzeitig vorgenommen werden. Wenn Sie es nicht verstehen, werden Sie wahrscheinlich an einigen Stellen stecken bleiben. Als Problemumgehung habe ich den Sperrmechanismus von "synchronisiert" auf "java.util.concurrent.locks.ReentrantLock" ersetzt.
//Der Konstrukteur ist fair=Geben Sie mit true an
//Die Sperrinstanz wird zwischen Threads verwendet, die ausschließlich gesteuert werden
ReentrantLock lock = new ReentrantLock(true);
try {
lock.lock();
//Verarbeitung während der exklusiven Kontrolle
} finally {
lock.unlock();
}
Ich kann den Zweck erreichen, selbst wenn ich ihn so benutze, wie er ist. Im Gegensatz zu "synchronisiert" muss die Sperre explizit freigegeben werden. Wenn sie versehentlich durchgesickert ist, kann dies zu einer ernsthaften Situation führen. Also habe ich einen Wrapper für ReentrantLock erstellt und ihn gezwungen, paarweise Sperren und Entsperrungen zu verwenden.
FairLock.java
public class FairLock {
private ReentrantLock lock = new ReentrantLock(true);
public void withSync(FairSyncTask task) {
try {
lock.lock();
task.act();
} finally {
lock.unlock();
}
}
public interface FairSyncTask {
void act();
}
}
Anwendungsbeispiel
//Beispiel synchronisiert geschrieben
private final Object syncObj = new Object();
public void actWithUnfair() {
synchronized(syncObj) {
//Verarbeitung während der exklusiven Kontrolle
}
}
//Beispiel durch ReentrantLock-Wrapper ersetzt
private final FairLock fairLock = new FairLock();
public void actWithFair() {
fairLock.withSync(() -> {
//Verarbeitung während der exklusiven Kontrolle
});
}
Ich frage mich, ob ich es wusste. Ich hoffe dieser Artikel hilft jemandem.