Erfahrene Java-Entwickler, die mit den verschiedenen M\u00f6glichkeiten zur Erstellung von Zufallswerten vertraut sind, k\u00f6nnen direkt zum Abschnitt \"Pseudozufallszahlen in Java\"<\/a> oder \"\u00c4nderungen der Implementierungen im Laufe der Zeit\"<\/a> springen.<\/p>\n\n\n\n Die Code-Beispiele zu diesem Artikel findest du in diesem GitHub-Repository<\/a>.<\/p>\n\n\n\n Dieses Kapitel zeigt die grundlegenden Klassen und Methoden zur Generierung einer Zufallszahl in Java und was bei deren Verwendung im Hinblick auf Threadsicherheit zu beachten ist.<\/p>\n\n\n\n Eine der \u00e4ltesten Methoden (sie existiert seit Java 1.0), um eine zuf\u00e4llige Flie\u00dfkommazahl zu generieren, ist der Aufruf von Der Aufruf liefert eine Zufallszahl zwischen 0 und 1. Genauer gesagt: eine Intern ruft Weitere Details zur internen Funktionalit\u00e4t und Threadsicherheit von Ebenfalls seit Java 1.0 dabei ist die Der Aufruf liefert eine zuf\u00e4llige Integer-Zahl im Bereich von Weitere Methoden zur Generierung von Zufallswerten sind:<\/p>\n\n\n\n Mit der Methode Mit der Einf\u00fchrung von Streams in Java 8 wurde Das folgende Beispiel gibt sieben Zufallszahlen auf der Konsole aus:<\/p>\n\n\n Die durch Zwei weitere Varianten erlauben die Angabe von Unter- und Obergrenze der generierten Werte. Das folgende Beispiel generiert sieben Zufallszahlen gr\u00f6\u00dfer oder gleich 0 und kleiner als 1.000 \u2013 einmal durch Jeweils entsprechende vier Varianten existieren f\u00fcr:<\/p>\n\n\n\n Da die erzeugten Werte keine echten Zufallszahlen sind, sondern eine Zufallszahl quasi aus der vorherigen berechnet wird (das ist stark vereinfacht ausgedr\u00fcckt; genaueres findest du im Kapitel \"Pseudozufallszahlen\"<\/a>) \u2013 und da diese Berechnung atomar erfolgen muss, ist der Aufruf der Methode mit einem gewissen Synchronisations-Overhead verbunden.<\/p>\n\n\n\n Viele gleichzeitige Aufrufe aus mehreren Threads k\u00f6nnen somit die Performance negativ beeinflussen. Im GitHub-Repo findest du das Programm RandomMultipleThreadsDemo<\/a>, das den Unterschied demonstriert.<\/p>\n\n\n\n Die folgende Grafik zeigt, wie lange es auf meinem 6-Core-i7 dauert 100 Millionen Zufallszahlen \u00fcber ein geteiltes Gemessen habe ich hier den Extremfall, in dem die Threads ununterbrochen Zufallszahlen generieren, also st\u00e4ndig Contention verursachen (Konflikte beim Zugriff auf den gemeinsamen Status). Sollte ein Thread nur gelegentlich eine Zufallszahl generieren, tritt Contention seltener auf und ist m\u00f6glicherweise gar nicht messbar.<\/p>\n\n\n\n Sofern du Thread-Contention erwartest und deine Anwendung nicht die Verwendung eines einzigen Zufallszahlengenerators erfordert (was nur in Ausnahmef\u00e4llen der Fall sein d\u00fcrfte), kannst du pro Thread ein separates Besser noch ist es das im folgenden Abschnitt beschriebene In Java 7 wurde die Klasse Wie man Zufallszahlen generiert<\/h2>\n\n\n\n
Java Math.random() Methode<\/h3>\n\n\n\n
Math.random()<\/code>:<\/p>\n\n\ndouble<\/span> d = Math.random();<\/code><\/span>Code-Sprache:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\ndouble<\/code>-Flie\u00dfkommazahl gr\u00f6\u00dfer oder gleich 0,0 und kleiner als 1,0.<\/p>\n\n\n\nMath.random()<\/code> ist laut Dokumentation threadsicher. Die Synchronisation ist allerdings von Java 1.3 bis einschlie\u00dflich Java 7 fehlerhaft. Solltest du mit einer dieser Versionen arbeiten, darfst du Math.random()<\/code> auf keinen Fall von verschiedenen Threads aus aufrufen.<\/p>\n\n\n\nMath.random()<\/code> die nextDouble()<\/code>-Methode einer in der Math<\/code>-Klasse gehaltenen statischen Instanz der im n\u00e4chsten Abschnitt besprochenen Random<\/code>-Klasse auf.<\/p>\n\n\n\nMath.random()<\/code> findest du im Kapitel \u00fcber die Implementierung dieser Methode<\/a>.<\/p>\n\n\n\nJava Random Klasse<\/h3>\n\n\n\n
java.util.Random<\/code>-Klasse. Mit dieser kannst du wie folgt eine zuf\u00e4llige int<\/code>-Zahl generieren:<\/p>\n\n\nRandom random = new<\/span> Random();\nint<\/span> i = random.nextInt();<\/code><\/span>Code-Sprache:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\nInteger.MIN_VALUE<\/code> (= -231<\/sup> = -2.147.483.648) bis Integer.MAX_VALUE<\/code> (= 231<\/sup>-1 = 2.147.483.647).<\/p>\n\n\n\n\n
nextInt(int bound)<\/code> \u2013 generiert eine Zufallszahl gr\u00f6\u00dfer oder gleich 0 und kleiner als der angegebene Grenzwert bound<\/code>.<\/li>\n\n\n\nnextLong()<\/code> \u2013 generiert einen zuf\u00e4lligen long<\/code>-Wert.<\/li>\n\n\n\nnextBoolean()<\/code> \u2013 liefert einen zuf\u00e4lligen Boolean-Wert, also true<\/code> oder false<\/code>.<\/li>\n\n\n\nnextFloat()<\/code> \u2013 liefert eine zuf\u00e4llig float<\/code>-Zahl gr\u00f6\u00dfer oder gleich 0,0 und kleiner als 1,0.<\/li>\n\n\n\nnextDouble()<\/code> \u2013 liefert eine zuf\u00e4llig double<\/code>-Zahl gr\u00f6\u00dfer oder gleich 0,0 und kleiner als 1,0 (diese Methode wird von Math.random()<\/code> aufgerufen, wie im vorherigen Abschnitt<\/a> beschrieben).<\/li>\n\n\n\nnextBytes(byte[] bytes)<\/code> \u2013 f\u00fcllt das angegebene byte<\/code>-Array mit zuf\u00e4lligen Bytes.<\/li>\n\n\n\nnextGaussian()<\/code> \u2013 liefert eine normal- bzw. Gau\u00df-verteilte Zufallszahl mit einer Standardabweichung von 1.0, d. h. dass entsprechend der Normalverteilung<\/a> die Wahrscheinlichkeit einer nahe der 0 liegenden Zahl h\u00f6her ist als die Wahrscheinlichkeit einer weit von der 0 entfernten Zahl.<\/li>\n<\/ul>\n\n\n\nsetSeed(long seed)<\/code> oder dem zweiten Konstruktor Random(long seed)<\/code> kannst du den sogenannten Startwert (englisch \"seed\") des Zufallszahlengenerators setzen. Das ist nur f\u00fcr besondere Anforderungen n\u00f6tig. Mehr dar\u00fcber erf\u00e4hrst du im Kapitel Pseudozufallszahlen<\/a>.<\/p>\n\n\n\nErweiterungen von java.util.Random in Java 8<\/h4>\n\n\n\n
java.util.Random<\/code> um Methoden zur Erzeugung von Zufallszahlen-Streams erweitert. Die Methode Random.ints()<\/code> generiert einen IntStream<\/code>: einen Stream von zuf\u00e4lligen int<\/code>-Werten.<\/p>\n\n\n\nRandom random = new<\/span> Random();\nrandom.ints().limit(7<\/span>).forEach(System.out::println);<\/code><\/span>Code-Sprache:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\nlimit(7)<\/code> gesetzte Limitierung auf sieben Elemente k\u00f6nnen wir auch in einer \u00fcberladenen Variante der ints()<\/code>-Methode anfordern:<\/p>\n\n\nRandom random = new<\/span> Random();\nrandom.ints(7<\/span>).forEach(System.out::println);<\/code><\/span>Code-Sprache:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\nlimits()<\/code> begrenzt und einmal durch den ersten Parameter der ints()<\/code>-Methode.<\/p>\n\n\nRandom random = new<\/span> Random();\nrandom.ints(0<\/span>, 1000<\/span>).limit(7<\/span>).forEach(System.out::println);\nrandom.ints(7<\/span>, 0<\/span>, 1000<\/span>).forEach(System.out::println);<\/code><\/span>Code-Sprache:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n\n
longs()<\/code> \u2013 generiert einen LongStream<\/code> von Zufallszahlen<\/li>\n\n\n\ndoubles()<\/code> \u2013 generiert einen DoubleStream<\/code> von Zufallszahlen<\/li>\n<\/ul>\n\n\n\nThreadsicherheit von java.util.Random<\/h4>\n\n\n\n
java.util.Random<\/code> ist threadsicher; du kannst also die Methoden eines einzigen Random<\/code>-Objekts sicher aus mehreren Threads aufrufen.<\/p>\n\n\n\nRandom<\/code>-Objekt zu erzeugen: bei einem Thread etwa eine Sekunde, bei sechs parallelen Threads \u00fcber 50 Sekunden:<\/p>\n\n\n![\"java.util.Random](\"https:\/\/www.happycoders.eu\/wp-content\/uploads\/2022\/01\/java-math-random-single-instance-performance-800x450.png\")
Random<\/code>-Objekt erzeugen \u2013 dann bleibt die Zeit f\u00fcr 100 Millionen Zufallszahlen bei etwa einer Sekunde, egal wie viele Threads parallel laufen (MultipleRandomMultipleThreadsDemo<\/a> in GitHub):<\/p>\n\n\n![\"java.util.Random](\"https:\/\/www.happycoders.eu\/wp-content\/uploads\/2022\/01\/java-math-random-multiple-instances-performance-800x450.png\")
ThreadLocalRandom<\/code> einsetzen.<\/p>\n\n\n\nJava ThreadLocalRandom Klasse<\/h3>\n\n\n\n
java.util.concurrent.ThreadLocalRandom<\/code> eingef\u00fchrt. Die statische Methode ThreadLocalRandom.current()<\/code> liefert pro Thread einen von allen anderen Threads unabh\u00e4ngigen Zufallszahlengenerator. So kann es zu keiner Thread-Contention kommen, und der im vorherigen Abschnitt beschriebene Synchronisations-Overhead f\u00e4llt weg.<\/p>\n\n\n\nThreadLocalRandom.current()<\/code> liefert ein ThreadLocalRandom<\/code>-Objekt, welches wiederum von Random<\/code> erbt und damit die gleichen Methoden bereitstellt, also z. B. nextInt()<\/code>:<\/p>\n\n\nRandom random = ThreadLocalRandom.current();\nint<\/span> randomNumber = random.nextInt();<\/code><\/span>Code-Sprache:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
![\"ThreadLocalRandom](\"https:\/\/www.happycoders.eu\/wp-content\/uploads\/2022\/01\/ThreadLocalRandom-performance-800x450.png\")