Séquence Générateur en Java pour les Id Unique

Je prévois d'écrire un générateur de séquence qui sera utilisé
dans mon REPOS des ressources de mise en œuvre de la classe pendant le post pour générer
id unique. Depuis chaque requête post est gérée par un thread séparé,
J'ai fait la variable volatile et méthode synchronisée.
Je n'ai pas d'option pour utiliser des séquences ou quelque chose qui
traditionnelle SGBD fournit.

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

c'est ce que j'ai à ce jour, et de la planification pour créer une variable de
SequenceGen dans mon REPOS de mise en Œuvre. Ma question est la volonté de
il casse quelque part ? J'ai testé avec les deux fils et je ne vois pas
toute valeur répétée.

faire nextNum méthode static pour le rendre sûr.
Si vos premiers essais montrent qu'il fonctionne et que votre logique dit, il doit travailler, en règle générale, vous ne devriez pas vous inquiéter à ce sujet plus et accepter que cela fonctionne (pour l'instant). S'inquiéter quand il fait pose un problème.
Pourquoi ne pas simplement utiliser un AtomicInteger?
Plus d'une jvm impliqués dans le processus? Dans votre POC, je suppose que vous utilisez une seule jvm.
Le champ doit être privé. volatile est redondante, puisque vous avez accès à l'aide d'une méthode synchronisée. Mais je suis d'accord avec fge: un AtomicInteger est un meilleur, plus sûr, plus rapide solution. Si vous prévoyez d'avoir plusieurs machines virtuelles, vous devez envisager d'utiliser un UUID à la place (mais vous aurez une Chaîne de caractères et non un int)

OriginalL'auteur Ayan | 2014-03-14

  1. 23

    Cela va fonctionner, cependant AtomicInteger est un type qui est parfait pour votre cas d'utilisation.

    AtomicInteger seq = new AtomicInteger();
int nextVal = seq.incrementAndGet();
    +1 Il y a aussi un bon poste existant sur l'utilisation de AtomicInteger un une séquence: stackoverflow.com/questions/14338533/atomicinteger-and-volatile
    Merci pour le pointeur, qui a aidé.

    OriginalL'auteur anttix

  2. 1

    Vous pouvez prendre avantage de java.util.préf.Préférences à persister à l'état actuel de votre générateur de séquence sur le disque et de le réutiliser plus tard.

    (aussi, vous souhaitez peut-être utiliser plusieurs générateurs de séquence)

    c'est à dire 

    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;
}
}
    Tirer de cette mise en œuvre, cette version stackoverflow.com/questions/1186387/... prise en charge du cache et de crash du serveur de récupération.

    OriginalL'auteur FaNaJ

  3. 1

    Si vous êtes ouvert à l'aide de String pour les Id, au lieu de int, vous voudrez peut-être regarder dans l'aide de UUID (Universally Unique Identifier). Très facile à utiliser et comme son nom l'indique, ils sont uniques. Voici un exemple de la façon de générer un:

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

    Un UUID fournit également une meilleure sécurité que le int parce qu'avec des entiers, vous pouvez deviner le prochain ID de la demande par simple ajout de 1 pour votre numéro de demande, mais Uuid ne sont pas séquentielles et les chances de quiconque en haleine de quelqu'un d'autre l'ID de la demande sont assez minces.

    Bien que vos commentaires sont corrects, il y a un énorme gain de performance lors de l'utilisation de l'UUID
    veuillez fournir des précisions. Combien de performances est-il?
    Dans mon cas, le rendement est très mauvais, donc je joint un profiler et se rendit compte qu'en fait, il frappe le disque dur. Vous pouvez toujours l'ajouter dans une boucle et de voir comment lent c'est pour vous HW. Au-dessous de la réponse qu'il a été 1100ms. stackoverflow.com/questions/14532976/...

    OriginalL'auteur SergeyB