Discussion :

[geforce]

Bonjour à tous
J’ai besoin de simulé un id en auto incrément en java (id dois être unique)

Quel est la façon la plus sécuritaire pour ne pas avoir des incohérences de données ?

Merci

[joel.drigo]

Salut,

Tu ne précises pas si ça doit fonctionner en monothread ou en multithread.

Il y a plusieurs moyens de la faire, dans le 2 cas, mais je pense que le plus simple est d'utiliser un AtomicInteger (ou AtomicLong, si tu veux un id en long), qui fonctionnera dans les 2 cas :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class MyObject {
 
   private static final AtomicInteger ID_FACTORY = new AtomicInteger();
   private final int id;
 
   public MyObject() {
      id = ID_FACTORY.getAndIncrement();
   }
 
   public final int getId() {
      return id;
   }
 
}

[hwoarang]

+1 pour AtomicInteger

[geforce]

Salut,

Tu ne précises pas si ça doit fonctionner en monothread ou en multithread.

Oui idéalement que ce soit thread-safe ! comment assuré le multithread?

Merci pour cette proposition que je vais utilisé,

[Nico02]

Salut,

Un AtomicInteger est déjà fait pour fonctionner dans un environnement Multithread. Il utilise en interne une variable volatile ce qui garanti implicitement que l'accès à cette donnée se fait de manière "synchronisé" (je met entre guillemet car le mécanisme réel n'est pas à proprement parlé une synchronisation -> c.f FAQ)

Cdt.

[geforce]

OK ok
juste pour la cas

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
 if(currentValue.get()==Long.MAX_VALUE)
                        currentValue=new AtomicLong(0);

Quel est les politiques a utilisé dans c'est cas la ?

Merci

[thelvin]

Humm. L'idée était que long était un type de taille suffisante.

Mais tu peux faire

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
while(true) {
  long currentValue = atomic.get();
 
  long nextValue;
  if(currentValue == Long.MAX_VALUE) {
    nextValue = 0;
  } else {
    nextValue = currentValue + 1;
  }
 
  if(atomic.compareAndSet(currentValue, nextValue)) {
    return currentValue;
  }
}

À noter que si tu fais juste getAndIncrement(), il va bel et bien boucler quand il atteindra la valeur max. Mais il repartira du plus bas nombre négatif, au lieu de zéro.

[tchize_]

Quel est les politiques a utilisé dans c'est cas la ?

Merci

il y a ~1e19 valeurs positives dans un long. Si ton programme tourne à plein tube pendant 10 ans (soit ~5e7 secondes), il faudrait qu'il génère 2e11 (200 milliards) d'ids par secondes pour faire sa première boucle....
La politique c'est "ça n'arrivera pas, on rebootera surement au moins une fois la machine pour maintenance sur cette période"