Sequenz-Generator in Java, der für die Eindeutige Id

Ich Plane, schreiben einen Sequenz-generator verwendet wird
in meiner REST-Ressource-Umsetzung Klasse während des post zu generieren
eindeutige id. Da jede post-Anforderung erfolgt durch separaten thread
Ich habe die variable volatile und Methode synchronisiert.
Ich habe keine option zur Verwendung von Sequenzen oder was
traditionelle RDBMS bietet.

public class SequenceGen {
    volatile static int n = 0;  
    public synchronized int nextNum(){
        return n++;
    }   
}

dies ist, was ich habe, so weit, und die Planung um eine variable zu erstellen von
SequenceGen in meinem REST-Implementierung. Meine eigentliche Frage ist, wird
es brechen irgendwo ? Getestet habe ich mit zwei threads und ich sehe nicht ein,
jeden Wert wiederholt.

  • machen nextNum Methode static machen es sicher.
  • Wenn Ihr die ersten tests zeigen, dass es geht und Ihre Logik sagt, es sollte funktionieren, im Allgemeinen sollte man keine sorgen mehr und akzeptieren, dass es funktioniert (jetzt). Sorgen machen, wenn es tatsächlich ein problem darstellt.
  • Warum nicht einfach ein AtomicInteger?
  • Mehr als eine jvm beteiligten in Ihrem Prozess? In Ihrem POC, ich nehme an, Sie sind mit einer einzigen jvm.
  • Das Feld sollte privat sein. volatile ist redundant, da Sie den Zugriff auf eine synchronisierte Methode. Aber ich Stimme mit fge: ein AtomicInteger ist eine bessere, sicherere und schnellere Lösung. Wenn Sie planen, mehrere VMs, sollten Sie erwägen, eine UUID statt (aber Sie erhalten eine Zeichenfolge, die nicht ein int)
  • Ich bin mit JVM nur
  • Nizet, Danke für den Hinweis private und Entlassungen. . Zunächst wollte ich nur halten Sie nur flüchtig. Ich werde AtomicInteger und erwägen, es zu benutzen.
  • volatile reicht nicht aus. ++ ist keine Atomare operation, und Sie könnte sich somit eine race condition. Auch Ihr methos sollte auf jeden Fall statisch sein. Ansonsten, deine threads synchronisieren sich auf zwei verschiedene Objekte, was bedeutet, dass Sie nicht die Synchronisation. Das ist ein bug, den Sie nicht hätte mit AtomicInteger, die inhärent thread-sicher.
  • Nizet, Liest und schreibt sind atomic für alle Variablen volatile deklariert (einschließlich long-und double-Variablen). aus docs.oracle.com/javase/tutorial/essential/concurrency/...
  • Eine lese-atomar ist. Ein schreiben ist atomar. Aber ++ macht zu Lesen, dann eine Schrittweite, dann schreiben. Und, dass die Reihenfolge der Operationen ist nicht atomar. Also zwei threads Lesen kann, den gleichen Wert, erhöhen Sie parallel, und das gleiche schreiben nächste Wert in parallel. Das ist, warum AtomicInteger.incrementAndGet() vorhanden ist.
  • Nizet, vielen Dank für die Erklärung. Ich werde AtomicInteger
  • Dieser statische Wert verloren, wenn wir den server neu starten, richtig?

InformationsquelleAutor Ayan | 2014-03-14
  1. 23

    Wird es funktionieren, jedoch AtomicInteger ist ein built-in-Typ, der ist perfekt für Ihren Anwendungsfall.

    AtomicInteger seq = new AtomicInteger();
int nextVal = seq.incrementAndGet();
    InformationsquelleAutor anttix
  2. 1

    Können Sie die Vorteile von java.util.prefs.Preferences zum speichern des aktuellen Status der Sequenz-generator auf der Festplatte und verwenden Sie es später erneut.

    (auch die, die Sie verwenden möchten, können mehrere Sequenz-Generatoren)

    d.h. 

    import java.lang.ref.SoftReference;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicLong;
import java.util.prefs.Preferences;

public final class SequenceGenerator {

    private static final Preferences PREFS = Preferences.userNodeForPackage(SequenceGenerator.class);
    private static final AtomicLong SEQ_ID = new AtomicLong(Integer.parseInt(PREFS.get("seq_id", "1")));
    private static final Map<Long, SoftReference<SequenceGenerator>> GENERATORS = new ConcurrentHashMap<>();
    private static final SequenceGenerator DEF_GENERATOR = new SequenceGenerator(0L, Long.parseLong(PREFS.get("seq_0", "1")));

    static {
        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
            GENERATORS.values().stream()
                    .map(SoftReference::get)
                    .filter(seq -> seq != null && seq.isPersistOnExit())
                    .forEach(SequenceGenerator::persist);
            if (DEF_GENERATOR.isPersistOnExit()) {
                DEF_GENERATOR.persist();
            }
            PREFS.put("seq_id", SEQ_ID.toString());
        }));
    }

    private final long sequenceId;
    private final AtomicLong counter;
    private final AtomicBoolean persistOnExit = new AtomicBoolean();

    private SequenceGenerator(long sequenceId, long initialValue) {
        this.sequenceId = sequenceId;
        counter = new AtomicLong(initialValue);
    }

    public long nextId() {
        return counter.getAndIncrement();
    }

    public long currentId() {
        return counter.get();
    }

    public long getSequenceId() {
        return sequenceId;
    }

    public boolean isPersistOnExit() {
        return persistOnExit.get();
    }

    public void setPersistOnExit(boolean persistOnExit) {
        this.persistOnExit.set(persistOnExit);
    }

    public void persist() {
        PREFS.put("seq_" + sequenceId, counter.toString());
    }

    @Override
    protected void finalize() throws Throwable {
        super.finalize();
        GENERATORS.remove(sequenceId);
        if (persistOnExit.get()) {
            persist();
        }
    }

    @Override
    public int hashCode() {
        return Long.hashCode(sequenceId);
    }

    @Override
    public boolean equals(Object obj) {
        return obj == this || obj != null && obj instanceof SequenceGenerator && sequenceId == ((SequenceGenerator) obj).sequenceId;
    }

    @Override
    public String toString() {
        return "{" +
                "counter=" + counter +
                ", seq=" + sequenceId +
                '}';
    }

    public static SequenceGenerator getDefault() {
        return DEF_GENERATOR;
    }

    public static SequenceGenerator get(long sequenceId) {
        if (sequenceId < 0) {
            throw new IllegalArgumentException("(sequenceId = " + sequenceId + ") < 0");
        }
        if (sequenceId == 0) {
            return DEF_GENERATOR;
        }
        SoftReference<SequenceGenerator> r = GENERATORS.computeIfAbsent(sequenceId, sid -> {
            try {
                return new SoftReference<>(new SequenceGenerator(sid, Long.parseLong(PREFS.get("seq_" + sid, null))));
            } catch (Throwable t) {
                return null;
            }
        });
        return r == null ? null : r.get();
    }

    public static SequenceGenerator create() {
        return create(1);
    }

    public static SequenceGenerator create(long initialValue) {
        long sequenceId = SEQ_ID.getAndIncrement();
        SequenceGenerator seq = new SequenceGenerator(sequenceId, Long.parseLong(PREFS.get("seq_" + sequenceId, "" + initialValue)));
        GENERATORS.put(sequenceId, new SoftReference<>(seq));
        return seq;
    }

}
    InformationsquelleAutor FaNaJ
  3. 1

    Wenn Sie offen sind mit String für die IDs, statt int, vielleicht möchten Sie sich in UUID (Universally Unique Identifier). Sehr einfach zu bedienen und wie der name schon sagt, sind Sie einzigartig. Hier ist ein Beispiel, wie zu generieren:

    //the value of uuid will be something like '03c9a439-fba6-41e1-a18a-4c542c12e6a8'
String uuid = java.util.UUID.randomUUID().toString()

    Einen UUID bietet auch besseren Schutz als int weil mit ganzen zahlen können Sie erraten, die nächste Anfrage-ID, indem Sie einfach 1, um Ihre request-ID, aber UUIDs sind nicht aufeinander Folgen, und die Chancen, jemanden zu raten jemand anderes die Anfrage-ID sind ziemlich schlank.

    • Obwohl Ihre Kommentare sind korrekt, es gibt eine riesige Leistungseinbußen bei der Verwendung von UUID
    • bitte erläutern Sie. Wie viel von einem performance-hit ist es?
    • In meinem Fall, war die Leistung sehr schlecht, sodass ich schonmal ein profiler und festgestellt, dass es tatsächlich trifft die HDD. Sie können immer fügen Sie es in eine Schleife und sehen, wie langsam ist es für Sie, HW. Unten In der Antwort war es 1100ms. stackoverflow.com/questions/14532976/...
    InformationsquelleAutor SergeyB
Schreibe einen Kommentar