Распределение случайных чисел

Быстрый Код:

// For occasional tasks that just need an average quality random number
ExecutorService threadPool = Executors.newCachedThreadPool();
threadPool.execute( () -> {
  ThreadLocalRandom.current().nextInt(); // Fast and unique!
} );


// For SecureRandom, high quality random number
final Random r = new SecureRandom();
ExecutorService threadPool = Executors.newCachedThreadPool();
threadPool.execute( () -> {
  r.nextInt(); // sun.security.provider.NativePRNG uses singleton.  Can't dodge contention.
} );


// Apache Common Math - Mersenne Twister - decent and non-singleton
int cpu = Runtime.getRuntime().availableProcessors();
ExecutorService executor = Executors.newFixedThreadPool( cpu );
Map<Thread, RandomGenerator> random = new WeakHashMap<>( cpu, 1.0f );

executor.execute( ()-> {
   RandomGenerator r;
   synchronized ( random ) { // Get or create generator.
      r = random.get( Thread.currentThread() );
      if ( r == null ) random.put( Thread.currentThread(), r = new MersenneTwister() );
   }
   r.nextInt( 1000 );
} );

объяснение:

1. два Random того же семени даст те же числа.
   1. таким образом, мы сосредоточимся на том, можем ли мы гарантировать различные семена.

2. в теории, new Random() в каждом потоке не гарантирует, разных семян.

   1. новый случайный заполнена nanoTime и "уникальный" число.
   2. число не гарантируется уникальным, поскольку его расчет не синхронизирован.
   3. что касается nanoTime, он гарантирует, что " по крайней мере, хорошо, как currentTimeMillis"
   4. currentTimeMillis ничего не гарантирует и может быть довольно грубой.
   5. в реальной жизни два раза одинаковы только на старые системы linux и Win 98.

3. на практике new Random() в каждом потоке в основном всегда получают разные семена.

   1. создание потока-это дорого. Шахта создает 1 на 50 000 НС. И это не медленно.
   2. 50μs путь над зернистостями nanoTime общими до несколько десятков НС.
   3. вычисление уникального номера (1.2) также быстро, поэтому получать такие же число очень редко.
   4. использовать исполнители создать нить бассейн чтобы избежать тяжелых новых потоков над головой.

4. zapl предложил ThreadLocalRandom.current().nextInt(). Великая идея.

   1. он не создает новый Random, а также линейный конгруэнтный генератор.
   2. он генерирует новый случайный для каждого потока вызовов, поскольку этот поток семя.
   3. оно построен для того чтобы быть очень быстр в multi-потоке. (См. Примечания ниже.)
   4. он статически засеян SecureRandom, которые производят более качественные случайные числа.

5. "uniformally распространяется" - это только одна небольшая часть случайность тесты.

   1. Random is несколько униформу, и его результат может быть предсказал дали всего две ценности.
   2. SecureRandom гарантии этого не происходит. (т. е. криптографически сильный)
   3. нет никакого риска столкновения семян, Если вы создадите новый SecureRandom в каждом потоке.
   4. но в настоящее время его источник один поток во всяком случае, нет параллельного поколения.
   5. для хорошего RNG, который поддерживает многопоточность, найдите внешняя помощь как Apache Common MT.

Примечание: детали реализации выведены из исходного кода Java 8. Будущая версия Java может измениться; например, ThreadLocalRandom использует sun.misc.Unsafe хранить семена, который могут быть удалены в Java 9 заставляя ThreadLocalRandom найти новый способ работы без разногласий.

нет.

нет никаких гарантий в отношении свойств распределения чисел, которые будут получены с помощью опции 1. Как было ясно в других ответах, реализация конструктора для java.util.Random зависит от системного времени. Таким образом, для того, чтобы сделать гарантию на свойства распределения номеров, которые вы получаете с вариантом 1, вам нужно будет иметь возможность сделать гарантии о распределении номеров, произведенных звонками программа позволяет получить системное время на любой платформе, где программа будет работать.

С вариантом 2, однако, есть математические гарантии, которые могут быть сделаны о распределении чисел, которые будут произведены во время одного выполнения программы. С линейным конгруэнтным генератором (алгоритм генерации псевдослучайных чисел, используемый java.util.Random) некоторые свойства случайности не так хороши, как с другими алгоритмами, но распределение гарантировано быть относительно однородным.

это не обязательно означает, что Вариант 1 не может служить вашим целям. Это зависит от того, что вы делаете.

Java инициализирует случайное семя с System.nanoTime() и последовательный счетчик. Это дает некоторую гарантию того, что семя будет отличаться для каждого вызова, хотя я бы воздержался от его криптографической защиты.

С точки зрения производительности-вы действительно ожидаете, что блокировка внутреннего состояния Random в опции 1 будет иметь большую производительность, чем все следующее:

• доступ и увеличение volatile долго
• получение текущего системного времени (что довольно дорого)
• динамическое выделение
• еще один объект для сбора мусора

мое предложение будет делать бенчмарки вашего реального приложения, чтобы узнать, но я ожидаю, что Вариант 1 будет самым медленным из всех трех.

по моему опыту, лучший баланс между хорошим распределением и производительностью дается с помощью чего-то вроде генератора "Messerne Twister"(см. В разделе Apache Commons) . Для еще более причудливого решения см. этой.