jdk-sandbox: comparison jdk/src/java.base/share/classes/java/util/concurrent/ThreadLocalRandom.java

equal deleted inserted replaced

-:8be65fea76fc
+:566b551b7820
 */
 package java.util.concurrent;
 import java.io.ObjectStreamField;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.VarHandle;
 import java.security.AccessControlContext;
 import java.util.Random;
 import java.util.Spliterator;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicLong;
 import java.util.function.LongConsumer;
 import java.util.stream.DoubleStream;
 import java.util.stream.IntStream;
 import java.util.stream.LongStream;
 import java.util.stream.StreamSupport;
-import jdk.internal.misc.Unsafe;
 /**
 * 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
 * internal documentation for explanations, which are not repeated
 * here.)  Because ThreadLocalRandoms are not splittable
 * though, we use only a single 64bit gamma.
 *
 * Because this class is in a different package than class Thread,
-* field access methods use Unsafe to bypass access control rules.
+* field access methods use VarHandles to bypass access control rules.
 * To conform to the requirements of the Random superclass
 * constructor, the common static ThreadLocalRandom maintains an
 * "initialized" field for the sake of rejecting user calls to
 * setSeed while still allowing a call from constructor.  Note
 * that serialization is completely unnecessary because there is
 static final void localInit() {
 int p = probeGenerator.addAndGet(PROBE_INCREMENT);
 int probe = (p == 0) ? 1 : p; // skip 0
 long seed = mix64(seeder.getAndAdd(SEEDER_INCREMENT));
 Thread t = Thread.currentThread();
-U.putLong(t, SEED, seed);
+SEED.set(t, seed);
-U.putInt(t, PROBE, probe);
+PROBE.set(t, probe);
 }
 /**
 * Returns the current thread's {@code ThreadLocalRandom}.
 *
 * @return the current thread's {@code ThreadLocalRandom}
 */
 public static ThreadLocalRandom current() {
-if (U.getInt(Thread.currentThread(), PROBE) == 0)
+if ((int) PROBE.get(Thread.currentThread()) == 0)
 localInit();
 return instance;
 }
 /**
 throw new UnsupportedOperationException();
 }
 final long nextSeed() {
 Thread t; long r; // read and update per-thread seed
-U.putLong(t = Thread.currentThread(), SEED,
+SEED.set(t = Thread.currentThread(),
-r = U.getLong(t, SEED) + GAMMA);
+(r = (long) SEED.get(t)) + GAMMA);
 return r;
 }
 /**
 * Generates a pseudorandom number with the indicated number of
 * Returns the probe value for the current thread without forcing
 * initialization. Note that invoking ThreadLocalRandom.current()
 * can be used to force initialization on zero return.
 */
 static final int getProbe() {
-return U.getInt(Thread.currentThread(), PROBE);
+return (int) PROBE.get(Thread.currentThread());
 }
 /**
 * Pseudo-randomly advances and records the given probe value for the
 * given thread.
 */
 static final int advanceProbe(int probe) {
 probe ^= probe << 13;   // xorshift
 probe ^= probe >>> 17;
 probe ^= probe << 5;
-U.putInt(Thread.currentThread(), PROBE, probe);
+PROBE.set(Thread.currentThread(), probe);
 return probe;
 }
 /**
 * Returns the pseudo-randomly initialized or updated secondary seed.
 */
 static final int nextSecondarySeed() {
 int r;
 Thread t = Thread.currentThread();
-if ((r = U.getInt(t, SECONDARY)) != 0) {
+if ((r = (int) SECONDARY.get(t)) != 0) {
 r ^= r << 13;   // xorshift
 r ^= r >>> 17;
 r ^= r << 5;
 }
 else if ((r = mix32(seeder.getAndAdd(SEEDER_INCREMENT))) == 0)
 r = 1; // avoid zero
-U.putInt(t, SECONDARY, r);
+SECONDARY.set(t, r);
 return r;
 }
 // Support for other package-private ThreadLocal access
 /**
 * Erases ThreadLocals by nulling out Thread maps.
 */
 static final void eraseThreadLocals(Thread thread) {
-U.putObject(thread, THREADLOCALS, null);
+THREADLOCALS.set(thread, null);
-U.putObject(thread, INHERITABLETHREADLOCALS, null);
+INHERITABLETHREADLOCALS.set(thread, null);
 }
 static final void setInheritedAccessControlContext(Thread thread,
 AccessControlContext acc) {
-U.putObjectRelease(thread, INHERITEDACCESSCONTROLCONTEXT, acc);
+INHERITEDACCESSCONTROLCONTEXT.setRelease(thread, acc);
-}
-/**
-* Returns a new group with the system ThreadGroup (the
-* topmost, parent-less group) as parent.  Uses Unsafe to
-* traverse Thread.group and ThreadGroup.parent fields.
-*/
-static final ThreadGroup createThreadGroup(String name) {
-if (name == null)
-throw new NullPointerException();
-try {
-long tg = U.objectFieldOffset
-(Thread.class.getDeclaredField("group"));
-long gp = U.objectFieldOffset
-(ThreadGroup.class.getDeclaredField("parent"));
-ThreadGroup group = (ThreadGroup)
-U.getObject(Thread.currentThread(), tg);
-while (group != null) {
-ThreadGroup parent = (ThreadGroup)U.getObject(group, gp);
-if (parent == null)
-return new ThreadGroup(group, name);
-group = parent;
-}
-} catch (ReflectiveOperationException e) {
-throw new Error(e);
-}
-// fall through if null as cannot-happen safeguard
-throw new Error("Cannot create ThreadGroup");
 }
 // Serialization support
 private static final long serialVersionUID = -5851777807851030925L;
 */
 private void writeObject(java.io.ObjectOutputStream s)
 throws java.io.IOException {
 java.io.ObjectOutputStream.PutField fields = s.putFields();
-fields.put("rnd", U.getLong(Thread.currentThread(), SEED));
+fields.put("rnd", (long) SEED.get(Thread.currentThread()));
 fields.put("initialized", true);
 s.writeFields();
 }
 /**
 // IllegalArgumentException messages
 static final String BAD_BOUND = "bound must be positive";
 static final String BAD_RANGE = "bound must be greater than origin";
 static final String BAD_SIZE  = "size must be non-negative";
-// Unsafe mechanics
+// VarHandle mechanics
-private static final Unsafe U = Unsafe.getUnsafe();
+private static final VarHandle SEED;
-private static final long SEED;
+private static final VarHandle PROBE;
-private static final long PROBE;
+private static final VarHandle SECONDARY;
-private static final long SECONDARY;
+private static final VarHandle THREADLOCALS;
-private static final long THREADLOCALS;
+private static final VarHandle INHERITABLETHREADLOCALS;
-private static final long INHERITABLETHREADLOCALS;
+private static final VarHandle INHERITEDACCESSCONTROLCONTEXT;
-private static final long INHERITEDACCESSCONTROLCONTEXT;
 static {
 try {
-SEED = U.objectFieldOffset
+MethodHandles.Lookup l = java.security.AccessController.doPrivileged(
-(Thread.class.getDeclaredField("threadLocalRandomSeed"));
+new java.security.PrivilegedAction<>() {
-PROBE = U.objectFieldOffset
+public MethodHandles.Lookup run() {
-(Thread.class.getDeclaredField("threadLocalRandomProbe"));
+try {
-SECONDARY = U.objectFieldOffset
+return MethodHandles.privateLookupIn(Thread.class,
-(Thread.class.getDeclaredField("threadLocalRandomSecondarySeed"));
+MethodHandles.lookup());
-THREADLOCALS = U.objectFieldOffset
+} catch (ReflectiveOperationException e) {
-(Thread.class.getDeclaredField("threadLocals"));
+throw new Error(e);
-INHERITABLETHREADLOCALS = U.objectFieldOffset
+}
-(Thread.class.getDeclaredField("inheritableThreadLocals"));
+}});
-INHERITEDACCESSCONTROLCONTEXT = U.objectFieldOffset
+SEED = l.findVarHandle(Thread.class,
-(Thread.class.getDeclaredField("inheritedAccessControlContext"));
+"threadLocalRandomSeed", long.class);
+PROBE = l.findVarHandle(Thread.class,
+"threadLocalRandomProbe", int.class);
+SECONDARY = l.findVarHandle(Thread.class,
+"threadLocalRandomSecondarySeed", int.class);
+Class<?> tlm = Class.forName("java.lang.ThreadLocal$ThreadLocalMap");
+THREADLOCALS = l.findVarHandle(Thread.class,
+"threadLocals", tlm);
+INHERITABLETHREADLOCALS = l.findVarHandle(Thread.class,
+"inheritableThreadLocals", tlm);
+INHERITEDACCESSCONTROLCONTEXT = l.findVarHandle(Thread.class,
+"inheritedAccessControlContext", AccessControlContext.class);
 } catch (ReflectiveOperationException e) {
 throw new Error(e);
 }
 }
 mix64(System.nanoTime()));
 // at end of <clinit> to survive static initialization circularity
 static {
 if (java.security.AccessController.doPrivileged(
-new java.security.PrivilegedAction<Boolean>() {
+new java.security.PrivilegedAction<>() {
 public Boolean run() {
 return Boolean.getBoolean("java.util.secureRandomSeed");
 }})) {
 byte[] seedBytes = java.security.SecureRandom.getSeed(8);
 long s = (long)seedBytes[0] & 0xffL;

changeset 43219	566b551b7820
parent 42322	c3474fef4fe4
child 43226	6fc9bdd300f1