jdk/src/java.base/share/classes/java/util/concurrent/ThreadLocalRandom.java
changeset 27797 7734f206f415
parent 25859 3317bb8137f4
child 32991 b27c76b82713
equal deleted inserted replaced
27796:5052f749052a 27797:7734f206f415
    34  */
    34  */
    35 
    35 
    36 package java.util.concurrent;
    36 package java.util.concurrent;
    37 
    37 
    38 import java.io.ObjectStreamField;
    38 import java.io.ObjectStreamField;
    39 import java.net.NetworkInterface;
       
    40 import java.util.Enumeration;
       
    41 import java.util.Random;
    39 import java.util.Random;
    42 import java.util.Spliterator;
    40 import java.util.Spliterator;
    43 import java.util.concurrent.atomic.AtomicInteger;
    41 import java.util.concurrent.atomic.AtomicInteger;
    44 import java.util.concurrent.atomic.AtomicLong;
    42 import java.util.concurrent.atomic.AtomicLong;
    45 import java.util.function.DoubleConsumer;
    43 import java.util.function.DoubleConsumer;
   145             long s = (long)(seedBytes[0]) & 0xffL;
   143             long s = (long)(seedBytes[0]) & 0xffL;
   146             for (int i = 1; i < 8; ++i)
   144             for (int i = 1; i < 8; ++i)
   147                 s = (s << 8) | ((long)(seedBytes[i]) & 0xffL);
   145                 s = (s << 8) | ((long)(seedBytes[i]) & 0xffL);
   148             return s;
   146             return s;
   149         }
   147         }
   150         long h = 0L;
   148         return (mix64(System.currentTimeMillis()) ^
   151         try {
       
   152             Enumeration<NetworkInterface> ifcs =
       
   153                     NetworkInterface.getNetworkInterfaces();
       
   154             boolean retry = false; // retry once if getHardwareAddress is null
       
   155             while (ifcs.hasMoreElements()) {
       
   156                 NetworkInterface ifc = ifcs.nextElement();
       
   157                 if (!ifc.isVirtual()) { // skip fake addresses
       
   158                     byte[] bs = ifc.getHardwareAddress();
       
   159                     if (bs != null) {
       
   160                         int n = bs.length;
       
   161                         int m = Math.min(n >>> 1, 4);
       
   162                         for (int i = 0; i < m; ++i)
       
   163                             h = (h << 16) ^ (bs[i] << 8) ^ bs[n-1-i];
       
   164                         if (m < 4)
       
   165                             h = (h << 8) ^ bs[n-1-m];
       
   166                         h = mix64(h);
       
   167                         break;
       
   168                     }
       
   169                     else if (!retry)
       
   170                         retry = true;
       
   171                     else
       
   172                         break;
       
   173                 }
       
   174             }
       
   175         } catch (Exception ignore) {
       
   176         }
       
   177         return (h ^ mix64(System.currentTimeMillis()) ^
       
   178                 mix64(System.nanoTime()));
   149                 mix64(System.nanoTime()));
   179     }
   150     }
   180 
   151 
   181     /**
   152     /**
   182      * The seed increment
   153      * The seed increment