Eine Einführung in die Methoden und Prinzipien der java.util.Random-Implementierung

Die Klasse java.util.Random in der Java-Utility-Klassenbibliothek bietet Methoden zum Generieren verschiedener Arten von Zufallszahlen. Der folgende Artikel stellt hauptsächlich relevante Informationen zum Implementierungsprinzip von java.util.Random vor Sehr detailliert, Freunde in Not können sich darauf beziehen.

Übersicht

java.util.Random kann Zufallszahlen der Typen int, long, float, double und Goussian generieren. Dies ist auch der größte Unterschied zur Methode Random() in java.lang.Math, die nur Zufallszahlen vom doppelten Typ generiert.

Instanzen dieser Klasse werden verwendet, um einen Strom von Pseudozufallszahlen zu generieren. Diese Klasse verwendet einen 48-Bit-Seed, der durch eine lineare Kongruenzformel modifiziert wird. Wenn zwei Instanzen von Random mit demselben Startwert erstellt werden, generieren sie dieselbe Zahlenfolge und geben sie zurück, indem sie für jede Instanz dieselbe Folge von Methodenaufrufen ausführen.

Beispiel

public class RandomTest {
 public static void main(String[] args) {
 testRandom();
 System.out.println("---------------------");
 testRandom();
 System.out.println("---------------------");
 testRandom();
 }
 
 public static void testRandom(){
 Random random = new Random(1);
 for(int i=0; i<5; i++){
  System.out.print(random.nextInt()+"\t");
 }
 System.out.println("");
 }
}

Ausgabeergebnis:

Aus den Ergebnissen haben wir herausgefunden, dass die Folge der erhaltenen Zufallszahlen konsistent ist, solange die Samen gleich sind. Es handelt sich um eine Implementierung von Pseudozufallszahlen, nicht von echten Zufallszahlen.

Zufällige Quellcode-Analyse

Zufällige Klassenstruktur

class Random implements java.io.Serializable {
 private final AtomicLong seed;

 private static final long multiplier = 0x5DEECE66DL;
 private static final long addend = 0xBL;
 private static final long mask = (1L << 48) - 1;
 private static final AtomicLong seedUniquifier = new AtomicLong(8682522807148012L);

Da sind Referenzen Die Konstruktionsmethode

public Random(long seed) {
 if (getClass() == Random.class)
  this.seed = new AtomicLong(initialScramble(seed));
 else {
  // subclass might have overriden setSeed
  this.seed = new AtomicLong();
  setSeed(seed);
 }
}

private static long initialScramble(long seed) {
 return (seed ^ multiplier) & mask;
}

generiert Zufallszahlen durch Übergabe eines Startwerts. Aus dem obigen Beispiel geht hervor, dass die Zufallszahlenfolge von demselben Startwert generiert wird ist bei jeder Verwendung gleich. Wenn Sie unterschiedliche Sequenzen generieren möchten, können Sie jedes Mal nur einen anderen Startwert übergeben.

Konstruktionsmethode ohne Parameter

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;
 }
}

Durch den Quellcode entdeckt, sind die Parameter- weniger Konstruktionsmethode, Es generiert automatisch einen Startwert für uns und verwendet die CAS-Spin-Methode, um sicherzustellen, dass der erhaltene Startwert jedes Mal unterschiedlich ist, wodurch sichergestellt wird, dass die jedes Mal erhaltene Zufallssequenz new Random() inkonsistent ist.

nextInt()-Methode: Int-Zufallszahl abrufen

public int nextInt() {
 return next(32);
}

protected int next(int bits) {
 long oldseed, nextseed;
 AtomicLong seed = this.seed;
 do {
  oldseed = seed.get();
  nextseed = (oldseed * multiplier + addend) & mask;
 } while (!seed.compareAndSet(oldseed, nextseed));
 return (int)(nextseed >>> (48 - bits));
}

Aus dem Code können wir Es wurde festgestellt, dass die generierte Anzahl jedes Mal mit einem festen Algorithmus generiert wird, solange der Startwert bestimmt ist. Solange der Startwert bestimmt ist, ist die generierte Reihenfolge jedes Mal festgelegt.

Jedes Mal, wenn der Seed aktualisiert wird, wird CAS verwendet, um ihn zu aktualisieren. In einer Umgebung mit hoher Parallelität ist die Leistung ein Problem.

Sicherheitsprobleme

Stellen Sie sich vor, es handelt sich um eine Lotterieplattform. Solange der Startwert festgelegt ist, ist die generierte Sequenz jedes Mal dieselbe Zeit . Auf diese Weise kann diese Lücke genutzt werden, um die Zahlen der nächsten Lottoziehung vorherzusagen, was von manchen Menschen leicht ausgenutzt werden kann.

jdk empfiehlt, dass Sie versuchen, SecureRandom zum Generieren von Zufallszahlen zu verwenden.

SecureRandom

SecureRandom ist ein starker Zufallszahlengenerator. Die Hauptanwendungsszenarien sind: Datennummern für Sicherheitszwecke, beispielsweise zum Generieren von Geheimnissen. Schlüssel oder Sitzungs-ID. Im obigen Artikel „Sicherheit von Pseudozufallszahlen“ wurden die Sicherheitsprobleme schwacher Zufallszahlengeneratoren für jedermann dargelegt. Die Verwendung starker Zufallszahlengeneratoren wie SecureRandom verringert das Risiko, dass etwas schief geht.

Um hochfeste Zufallszahlen zu generieren, gibt es zwei wichtige Faktoren: Startwert und Algorithmus. Es kann viele Algorithmen geben, und normalerweise ist die Auswahl des Startwerts ein sehr kritischer Faktor. Beispielsweise ist der Startwert von Random System.currentTimeMillis(), sodass seine Zufallszahlen vorhersehbare und schwache Pseudozufallszahlen sind.
Die Idee, starke Pseudozufallszahlen zu generieren: Sammeln Sie verschiedene Computerinformationen, Tastatureingabezeit, Speichernutzungsstatus, freien Speicherplatz auf der Festplatte, E/A-Verzögerung, Anzahl der Prozesse, Anzahl der Threads und andere Informationen, CPU-Uhr, um eine annähernd zufällige Zahl zu erhalten Die Samen erreichen hauptsächlich Unvorhersehbarkeit.

Um es einfach auszudrücken: Verwenden Sie einen Verschlüsselungsalgorithmus, um einen sehr langen Zufallsstartwert zu generieren, sodass Sie den Startwert nicht erraten und daher die Zufallssequenznummer nicht ableiten können.

Zufällige Leistungsprobleme

Aus dem Random-Quellcode haben wir herausgefunden, dass CAS verwendet wird, um den Startwert jedes Mal zu aktualisieren, wenn eine Zufallszahl erhalten wird. Wert. Auf diese Weise kommt es in einer Umgebung mit hoher Parallelität zu einer großen Anzahl von CAS-Wiederholungsversuchen, was zu Leistungseinbußen führt. Zu diesem Zeitpunkt wird empfohlen, die ThreadLocalRandom-Klasse zum Generieren von Zufallszahlen zu verwenden.

ThreadLocalRandom-Implementierungsprinzip

Thread-Klasse

In der Thread-Klasse gibt es eine threadLocalRandomSeed-Eigenschaft.

ThreadLocalRandom-Struktur

Die SEED-Variable ist der Offset von threadLocalRandomSeed im Thread-Objekt.

ThreadLocalRandom.nextSeed()-Methode

Anhand dieser Methode stellen wir fest, dass der Startwert jedes Threads in In gespeichert ist die threadLocalRandomSeed-Eigenschaft des Thread-Objekts.

Fazit

Da die Seeds in ThreadLocalRandom in Thread-Objekten gespeichert werden, wird CAS nicht verwendet, um eine hohe Parallelität beim Erwerb von Random-Objekten sicherzustellen. Die jedes Mal erhaltenen Werte sind inkonsistent.
Jeder Thread verwaltet seinen eigenen Startwert. Wenn jeder Thread Zufallszahlen erhalten muss, erhält er den Startwert des aktuellen Threads vom aktuellen Thread-Objekt und erhält so die Leistung erheblich.

Das obige ist der detaillierte Inhalt vonEine Einführung in die Methoden und Prinzipien der java.util.Random-Implementierung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!