All Downloads are FREE. Search and download functionalities are using the official Maven repository.

io.netty.util.internal.ThreadLocalRandom Maven / Gradle / Ivy

There is a newer version: 5.0.0.Alpha2
Show newest version
/*
 * Copyright 2014 The Netty Project
 *
 * The Netty Project licenses this file to you under the Apache License,
 * version 2.0 (the "License"); you may not use this file except in compliance
 * with the License. You may obtain a copy of the License at:
 *
 *   https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations
 * under the License.
 */

/*
 * Written by Doug Lea with assistance from members of JCP JSR-166
 * Expert Group and released to the public domain, as explained at
 * https://creativecommons.org/publicdomain/zero/1.0/
 */

package io.netty.util.internal;

import static io.netty.util.internal.ObjectUtil.checkPositive;

import io.netty.util.internal.logging.InternalLogger;
import io.netty.util.internal.logging.InternalLoggerFactory;

import java.lang.Thread.UncaughtExceptionHandler;
import java.security.SecureRandom;
import java.util.Random;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicLong;

/**
 * A random number generator isolated to the current thread.  Like the
 * global {@link java.util.Random} generator used by the {@link
 * java.lang.Math} class, a {@code ThreadLocalRandom} is initialized
 * with an internally generated seed that may not otherwise be
 * modified. When applicable, use of {@code ThreadLocalRandom} rather
 * than shared {@code Random} objects in concurrent programs will
 * typically encounter much less overhead and contention.  Use of
 * {@code ThreadLocalRandom} is particularly appropriate when multiple
 * tasks (for example, each a {@link io.netty.util.internal.chmv8.ForkJoinTask}) use random numbers
 * in parallel in thread pools.
 *
 * 

Usages of this class should typically be of the form: * {@code ThreadLocalRandom.current().nextX(...)} (where * {@code X} is {@code Int}, {@code Long}, etc). * When all usages are of this form, it is never possible to * accidently share a {@code ThreadLocalRandom} across multiple threads. * *

This class also provides additional commonly used bounded random * generation methods. * * //since 1.7 * //author Doug Lea */ @SuppressWarnings("all") public final class ThreadLocalRandom extends Random { private static final InternalLogger logger = InternalLoggerFactory.getInstance(ThreadLocalRandom.class); private static final AtomicLong seedUniquifier = new AtomicLong(); private static volatile long initialSeedUniquifier; private static final Thread seedGeneratorThread; private static final BlockingQueue seedQueue; private static final long seedGeneratorStartTime; private static volatile long seedGeneratorEndTime; static { initialSeedUniquifier = SystemPropertyUtil.getLong("io.netty.initialSeedUniquifier", 0); if (initialSeedUniquifier == 0) { boolean secureRandom = SystemPropertyUtil.getBoolean("java.util.secureRandomSeed", false); if (secureRandom) { seedQueue = new LinkedBlockingQueue(); seedGeneratorStartTime = System.nanoTime(); // Try to generate a real random number from /dev/random. // Get from a different thread to avoid blocking indefinitely on a machine without much entropy. seedGeneratorThread = new Thread("initialSeedUniquifierGenerator") { @Override public void run() { final SecureRandom random = new SecureRandom(); // Get the real random seed from /dev/random final byte[] seed = random.generateSeed(8); seedGeneratorEndTime = System.nanoTime(); long s = ((long) seed[0] & 0xff) << 56 | ((long) seed[1] & 0xff) << 48 | ((long) seed[2] & 0xff) << 40 | ((long) seed[3] & 0xff) << 32 | ((long) seed[4] & 0xff) << 24 | ((long) seed[5] & 0xff) << 16 | ((long) seed[6] & 0xff) << 8 | (long) seed[7] & 0xff; seedQueue.add(s); } }; seedGeneratorThread.setDaemon(true); seedGeneratorThread.setUncaughtExceptionHandler(new UncaughtExceptionHandler() { @Override public void uncaughtException(Thread t, Throwable e) { logger.debug("An exception has been raised by {}", t.getName(), e); } }); seedGeneratorThread.start(); } else { initialSeedUniquifier = mix64(System.currentTimeMillis()) ^ mix64(System.nanoTime()); seedGeneratorThread = null; seedQueue = null; seedGeneratorStartTime = 0L; } } else { seedGeneratorThread = null; seedQueue = null; seedGeneratorStartTime = 0L; } } public static void setInitialSeedUniquifier(long initialSeedUniquifier) { ThreadLocalRandom.initialSeedUniquifier = initialSeedUniquifier; } public static long getInitialSeedUniquifier() { // Use the value set via the setter. long initialSeedUniquifier = ThreadLocalRandom.initialSeedUniquifier; if (initialSeedUniquifier != 0) { return initialSeedUniquifier; } synchronized (ThreadLocalRandom.class) { initialSeedUniquifier = ThreadLocalRandom.initialSeedUniquifier; if (initialSeedUniquifier != 0) { return initialSeedUniquifier; } // Get the random seed from the generator thread with timeout. final long timeoutSeconds = 3; final long deadLine = seedGeneratorStartTime + TimeUnit.SECONDS.toNanos(timeoutSeconds); boolean interrupted = false; for (;;) { final long waitTime = deadLine - System.nanoTime(); try { final Long seed; if (waitTime <= 0) { seed = seedQueue.poll(); } else { seed = seedQueue.poll(waitTime, TimeUnit.NANOSECONDS); } if (seed != null) { initialSeedUniquifier = seed; break; } } catch (InterruptedException e) { interrupted = true; logger.warn("Failed to generate a seed from SecureRandom due to an InterruptedException."); break; } if (waitTime <= 0) { seedGeneratorThread.interrupt(); logger.warn( "Failed to generate a seed from SecureRandom within {} seconds. " + "Not enough entropy?", timeoutSeconds ); break; } } // Just in case the initialSeedUniquifier is zero or some other constant initialSeedUniquifier ^= 0x3255ecdc33bae119L; // just a meaningless random number initialSeedUniquifier ^= Long.reverse(System.nanoTime()); ThreadLocalRandom.initialSeedUniquifier = initialSeedUniquifier; if (interrupted) { // Restore the interrupt status because we don't know how to/don't need to handle it here. Thread.currentThread().interrupt(); // Interrupt the generator thread if it's still running, // in the hope that the SecureRandom provider raises an exception on interruption. seedGeneratorThread.interrupt(); } if (seedGeneratorEndTime == 0) { seedGeneratorEndTime = System.nanoTime(); } return initialSeedUniquifier; } } private static long newSeed() { for (;;) { final long current = seedUniquifier.get(); final long actualCurrent = current != 0? current : getInitialSeedUniquifier(); // L'Ecuyer, "Tables of Linear Congruential Generators of Different Sizes and Good Lattice Structure", 1999 final long next = actualCurrent * 181783497276652981L; if (seedUniquifier.compareAndSet(current, next)) { if (current == 0 && logger.isDebugEnabled()) { if (seedGeneratorEndTime != 0) { logger.debug(String.format( "-Dio.netty.initialSeedUniquifier: 0x%016x (took %d ms)", actualCurrent, TimeUnit.NANOSECONDS.toMillis(seedGeneratorEndTime - seedGeneratorStartTime))); } else { logger.debug(String.format("-Dio.netty.initialSeedUniquifier: 0x%016x", actualCurrent)); } } return next ^ System.nanoTime(); } } } // Borrowed from // http://gee.cs.oswego.edu/cgi-bin/viewcvs.cgi/jsr166/src/main/java/util/concurrent/ThreadLocalRandom.java private static long mix64(long z) { z = (z ^ (z >>> 33)) * 0xff51afd7ed558ccdL; z = (z ^ (z >>> 33)) * 0xc4ceb9fe1a85ec53L; return z ^ (z >>> 33); } // same constants as Random, but must be redeclared because private private static final long multiplier = 0x5DEECE66DL; private static final long addend = 0xBL; private static final long mask = (1L << 48) - 1; /** * The random seed. We can't use super.seed. */ private long rnd; /** * Initialization flag to permit calls to setSeed to succeed only * while executing the Random constructor. We can't allow others * since it would cause setting seed in one part of a program to * unintentionally impact other usages by the thread. */ boolean initialized; // Padding to help avoid memory contention among seed updates in // different TLRs in the common case that they are located near // each other. private long pad0, pad1, pad2, pad3, pad4, pad5, pad6, pad7; /** * Constructor called only by localRandom.initialValue. */ ThreadLocalRandom() { super(newSeed()); initialized = true; } /** * Returns the current thread's {@code ThreadLocalRandom}. * * @return the current thread's {@code ThreadLocalRandom} */ public static ThreadLocalRandom current() { return InternalThreadLocalMap.get().random(); } /** * Throws {@code UnsupportedOperationException}. Setting seeds in * this generator is not supported. * * @throws UnsupportedOperationException always */ @Override public void setSeed(long seed) { if (initialized) { throw new UnsupportedOperationException(); } rnd = (seed ^ multiplier) & mask; } @Override protected int next(int bits) { rnd = (rnd * multiplier + addend) & mask; return (int) (rnd >>> (48 - bits)); } /** * Returns a pseudorandom, uniformly distributed value between the * given least value (inclusive) and bound (exclusive). * * @param least the least value returned * @param bound the upper bound (exclusive) * @throws IllegalArgumentException if least greater than or equal * to bound * @return the next value */ public int nextInt(int least, int bound) { if (least >= bound) { throw new IllegalArgumentException(); } return nextInt(bound - least) + least; } /** * Returns a pseudorandom, uniformly distributed value * between 0 (inclusive) and the specified value (exclusive). * * @param n the bound on the random number to be returned. Must be * positive. * @return the next value * @throws IllegalArgumentException if n is not positive */ public long nextLong(long n) { checkPositive(n, "n"); // Divide n by two until small enough for nextInt. On each // iteration (at most 31 of them but usually much less), // randomly choose both whether to include high bit in result // (offset) and whether to continue with the lower vs upper // half (which makes a difference only if odd). long offset = 0; while (n >= Integer.MAX_VALUE) { int bits = next(2); long half = n >>> 1; long nextn = ((bits & 2) == 0) ? half : n - half; if ((bits & 1) == 0) { offset += n - nextn; } n = nextn; } return offset + nextInt((int) n); } /** * Returns a pseudorandom, uniformly distributed value between the * given least value (inclusive) and bound (exclusive). * * @param least the least value returned * @param bound the upper bound (exclusive) * @return the next value * @throws IllegalArgumentException if least greater than or equal * to bound */ public long nextLong(long least, long bound) { if (least >= bound) { throw new IllegalArgumentException(); } return nextLong(bound - least) + least; } /** * Returns a pseudorandom, uniformly distributed {@code double} value * between 0 (inclusive) and the specified value (exclusive). * * @param n the bound on the random number to be returned. Must be * positive. * @return the next value * @throws IllegalArgumentException if n is not positive */ public double nextDouble(double n) { checkPositive(n, "n"); return nextDouble() * n; } /** * Returns a pseudorandom, uniformly distributed value between the * given least value (inclusive) and bound (exclusive). * * @param least the least value returned * @param bound the upper bound (exclusive) * @return the next value * @throws IllegalArgumentException if least greater than or equal * to bound */ public double nextDouble(double least, double bound) { if (least >= bound) { throw new IllegalArgumentException(); } return nextDouble() * (bound - least) + least; } private static final long serialVersionUID = -5851777807851030925L; }





© 2015 - 2024 Weber Informatics LLC | Privacy Policy