Einzigartige random-Nummer für einen bestimmten timestamp

Bin ich irgendwie learning-Konzepte von Random number generation & Multi-Threading in java.

Die Idee ist, nicht die Erzeugung eine wiederholte zufällige Anzahl Reihe 1000 in einer bestimmten Millisekunde (wenn man Bedenkt, dass nicht mehr als 50 Daten, die in einem Multithreading-fähigen Weise verarbeitet werden, in einer Millisekunde). So, die Liste von zufällig generierten Nummer, die auf bestimmte Zeit ist einzigartig. Können Sie mir eine Idee, wie ich am Ende der Generierung paar wiederholt Zufallszahlen (auch, gibt es eine beträchtliche Wahrscheinlichkeit) in eine bestimmte milli Sekunde.

Ich habe versucht, die folgenden Dinge, wo ich versagt habe.

Random random = new Random(System.nanoTime());
double randomNum = random.nextInt(999);

int min=1; int max=999;
double randomId = (int)Math.abs(math.Random()* (max - min + 1) + min);

Random random = new Random(System.nanoTime()); //also tried new Random();
double randomId = (int)Math.abs(random.nextDouble()* (max - min + 1) + min);

Als ich bin, indem der Zeitstempel, der generiert wird, in einer Multithread-Umgebung, die ich sehen, die gleichen ids (um die 8-10), die erzeugt wird (2-4 mal) für 5000+ einzigartige Daten.

Was haben Sie bisher ausprobiert? Bitte fügen Sie einige Ihrer code. Wo genau ist das problem?
Es wäre besser, Sie würde versuchen zu klären, eine Sache nach der anderen. Zum Beispiel, multithreading hat nichts zu tun mit der Erzeugung von Zufallszahlen, also sollten wir nicht verwechseln.
Was sind die max und min?
gud fangen ingo, habe ich begonnen zu geben etwas andere Frage!!! endete diese Frage zu stellen!!
min und max sind im Bereich 1-999!

InformationsquelleAutor Logan | 2013-10-01

2

Diese Klasse ermöglicht es Ihnen, sich einmalig auftretenden Werten aus einen bestimmten Bereich, bis die ganze Reihe verwendet wurde. Sobald die Palette verwendet wird, wird es neu initialisiert werden.

Klasse kommt zusammen mit einem einfachen test.

Wenn Sie möchten, dass die Klasse thread-sicher, fügen Sie einfach synchronized zu nextInt() Erklärung.

Dann können Sie das singleton-Muster oder einfach nur eine statische variable zum Zugriff auf den generator aus mehreren threads. Auf diese Weise werden alle Ihre threads wird das gleiche Objekt und die gleiche einzigartige id-pool.
```
public class NotRepeatingRandom {
    int size;
    int index;
    List<Integer> vals;
    Random gen = new Random();

    public NotRepeatingRandom(int rangeMax) {
      size = rangeMax;
      index = rangeMax; //to force initial shuffle
      vals = new ArrayList<Integer>(size);
      fillBaseList();
    }

    private void fillBaseList() {
      for (int a=0; a<size; a++) {
        vals.add(a);
      }
    }

    public int nextInt() {
      if (index == vals.size()) {
          Collections.shuffle(vals);
          index = 0;
      }
      int val = vals.get(index);
      index++;      
      return val;
    }

    public static void main(String[] args) {
        NotRepeatingRandom gen = new NotRepeatingRandom(10);
        for (int a=0; a<30; a++) {
            System.out.println(gen.nextInt());
        }
    }
}
```
- AUA - für eine naive Umsetzung, ich mag wohin es geht, aber Sie haben einige schreckliche performance-Probleme. Ständig entfernen Sie ein element zufällig wie, die bewirken, dass das gesamte array verschoben werden (ein element......in...ein...mal...). Besser zu mischen curVals im rebuildCurVals(), und dann ständig entfernen der letzten - element in der Liste. Oder vielleicht suchen Sie in einem anderen (vielleicht Brauch Queue Umsetzung?) Daten-Struktur.
- du hast Recht, aber ich fühle mich sehr stark über die nach dem ersten Gesetz der Optimierung, die "nicht optimieren". Die Klasse ist gut gekapselt und kann leicht ersetzt werden, mit einer optimalen Umsetzung, wenn solche Notwendigkeit entsteht.
- aber OK, ich optimierte den code ein wenig, da es einfach war das...
- Statt zwei Listen, speichern nur einen int zeigt auf den nächsten index von baseVals. Erhöhen Sie ihn um, wenn nextInt() genannt wird und als index > baseVals.size(): shuffle baseVals, dann wird der index zurückgesetzt auf null.
- hier gehen Sie. Ich denke immer noch, dass die Optimierung ist eine andere Frage.
- +1 wie Sie korrigierte meine falschen Regierungsumbildung Zustand (: .
InformationsquelleAutor Dariusz
4

Ersten, die Sie verwenden sollten new Random(), da sieht es wie diese (Einzelheiten hängen von der Java-version):
```
 public Random() { this(++seedUniquifier + System.nanoTime()); }
 private static volatile long seedUniquifier = 8682522807148012L;
```
I. e. es macht bereits Gebrauch von nanoTime() und stellt sicher, dass verschiedene threads mit dem gleichen nanoTime() Ergebnis bekommen verschiedene Samen, die new Random(System.nanoTime()) nicht.

(EDIT: Pyranja wies darauf hin, dies ist ein bug in Java 6, aber es ist behoben in Java 7:
```
public Random() {
    this(seedUniquifier() ^ System.nanoTime());
}

private static long seedUniquifier() {
    //L'Ecuyer, "Tables of Linear Congruential Generators of
    //Different Sizes and Good Lattice Structure", 1999
    for (;;) {
        long current = seedUniquifier.get();
        long next = current * 181783497276652981L;
        if (seedUniquifier.compareAndSet(current, next))
            return next;
    }
}

private static final AtomicLong seedUniquifier
    = new AtomicLong(8682522807148012L);
```
)

Zweitens, wenn Sie generieren 50 zufällige zahlen von 1 bis 1000, ist die Wahrscheinlichkeit, einige zahlen werden die gleichen sein, ist Recht hoch, Dank das Geburtstags-Paradoxon.

Dritten, wenn Sie wollen einfach nur eine eindeutige id, Sie konnte einfach AtomicInteger Zähler anstelle von Zufallszahlen. Oder, wenn Sie möchten, eine zufällige Teil, mit zu beginnen, fügen Sie einen Zähler, als auch zur Eindeutigkeit zu gewährleisten.
- Imho sind die gezeigten Mechanismus ist nicht thread-safe. Es ist möglich, dass zwei verschiedene threads die gleiche seedUniquifier. Obwohl seedUniquifier ist flüchtig, die ++ operator ist nicht atomic. Um auf der sicheren Seite sein, sollte man Sie nutzen ein AtomicInteger oder AtomicLong zu halten, den Ausgangswert oder mit anderen Mitteln der ordnungsgemäße Synchronisierung.
- Guter Punkt. Das ist wahrscheinlich, warum es behoben wurde in Java 7, die nicht verwenden, AtomicLong.
InformationsquelleAutor Alexey Romanov
0

Wenn ich verstehe deine Frage richtig, mehrere threads erstellen Ihre eigenen Instanzen der Random-Klasse zur gleichen Zeit und alle threads erzeugen die gleiche zufällige Zahl?
Gleiche Zahl erzeugt wird, weil alle random-Instanzen, wo zur gleichen Zeit erstellt, d.h. mit dem gleichen seed.

Dieses Problem zu beheben, erstellen Sie nur eine Instanz der Random-Klasse, die gemeinsam von allen threads so, dass alle deine threads aufrufen nextDouble() auf die gleiche Instanz. Random.nextDouble () - Klasse ist thread-sicher und wird implizit für die Aktualisierung seiner Samen mit jedem Aufruf.
```
//create only one Random instance, seed is based on current time
public static final Random generator= new Random();
```
Nun alle threads die gleiche Instanz:
```
double random=generator.nextDouble() 
```
InformationsquelleAutor Sergej Panic

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.