精华内容
下载资源
问答
  • 线程生成一个随机数
    2021-03-10 10:05:30

    用线程生成一个随机数

    我想用线程生成一个随机数,然后被另外一个函数调用,请问应该怎样做?

    这样行吗?

    Th1()xtends Thread

    {

    int x;

    Th1(int x){this.x=x;}

    public void run()

    {

    x=(int)(Math.random()*100+0.5);

    }

    搜索更多相关的解决方案:

    随机数  线程

    ----------------解决方案--------------------------------------------------------

    不行就和你要获得时间一样 你到别的函数调用 只是获得了 当前时间的X值 建议你把要用X的函数写在这里的run方法里面

    ----------------解决方案--------------------------------------------------------

    这样啊....但是题目就 是要利用线程随机生成一个整数n,然后在用另一个线程生成n个随机数!有什么 好办法吗?

    ----------------解决方案--------------------------------------------------------

    互相调用啊,用一个get方法不就可以了

    ----------------解决方案--------------------------------------------------------

    凡是涉及到多线程的,都必须非常小心。

    表面上看起来用一个get就可以了,实际上却不是

    比如说

    RandomThread rt = new RandomThread();

    rt.start();

    int n = rt.getRandomNumber();

    关键问题来了,n的值是多少?

    rt.getRandomNumber()这个方法会在RandomThread的run方法调用之后调用,还是调用之前调用,或者是调用的过程中调用?

    我们正确的逻辑应该是run调用完之后调用,所以可以用join方法。

    另外,用另外一个线程生成n个随机数这个也会和生成随机数n一样的问题。也可以用join方法解决。

    当然也可以用一个对象锁 int[] lock = new int[0];来对线程进行同步,抱歉说了那么多话却没有一行代码,因为在网吧,所以懒得写了

    [此贴子已经被作者于2007-6-21 21:35:48编辑过]

    ----------------解决方案--------------------------------------------------------

    我服了你

    ----------------解决方案--------------------------------------------------------

    我用get 的方法就老是在run调用前就调用了get.得不到随机数..

    ----------------解决方案--------------------------------------------------------

    你run一直在那里循环

    然后你随时调用get就可以,

    ----------------解决方案--------------------------------------------------------

    我在线程启动后就调用get,就算run里面用了循环也不能一定保证run 在get之前调用了.

    ----------------解决方案--------------------------------------------------------

    你在构造函数里面就先来一个随机数嘛,

    这就能保证对象在生成的时候,就已经有随机数了,然后在线程里面再一直的随机

    ----------------解决方案--------------------------------------------------------

    更多相关内容
  • java随机数的陷阱

    2021-02-26 09:28:36
    java中的随机数我们需要在Java中随机生成一个数字。java开发中我们通常使用java.util.Random来搞,它提供了一种伪随机的生成机制。Jvm 通过传入的种子(seed)来确定生成随机数的区间,只要种子一样,获取的随...

    前言

    随机数我们应该不陌生,业务中我们用它来生成验证码,或者对重复性要求不高的id,甚至我们还用它在年会上搞抽奖。今天我们来探讨一下这个东西。如果使用不当会引发一系列问题。

    java中的随机数

    我们需要在Java中随机生成一个数字。java开发中我们通常使用java.util.Random来搞,它提供了一种伪随机的生成机制。Jvm 通过传入的种子(seed)来确定生成随机数的区间,只要种子一样,获取的随机数的序列就是一致的。而且生成的结果都是可以预测的。是一种伪随机数的实现,而不是真正的随机数。来确定使用的但是有些用例直接使用可能会导致一些意想不到的问题。Random的一个普遍用法:

    // Random 实例

    Random random = new Random();

    //调用 nextInt() 方法 此外还有nextDouble(), nextBoolean(), nextFloat(), ...

    random.nextInt();

    或者,我们可以使用java中的数学计算类:

    Math.random();

    Math类只包含一个Random实例来生成随机数:

    public static double random() {

    Random rnd = randomNumberGenerator;

    if (rnd == null) {

    // 返回一个新的Random实例

    rnd = initRNG();

    return rnd.nextDouble();

    }

    java.util.Random的用法是线程安全的。但是,在不同线程上并发使用相同的Random实例可能会导致争用,从而导致性能不佳。其原因是使用所谓的种子来生成随机数。种子是一个简单的数字,它为生成新的随机数提供了基础。我们来看看Random中的next(int bits)方法:

    protected int next(int bits) {

    long oldseed, nextseed;

    AtomicLong seed = this.seed;

    do {

    oldseed = seed.get();

    nextseed = (oldseed * multiplier addend) & mask;

    } while (!seed.compareAndSet(oldseed, nextseed));

    return (int)(nextseed >>> (48 - bits));}

    首先,旧种子和新种子存储在两个辅助变量上。在这一点上,创造新种子的原则并不重要。要保存新种子,使用compareAndSet()方法将旧种子替换为下一个新种子,但这仅仅在旧种子对应于当前设置的种子的条件下才会触发。如果此时的值由并发线程操纵,则该方法返回false,这意味着旧值与例外值不匹配。因为是循环内进行的操作,那么会发生自旋,直到变量与例外值匹配。这可能会导致性能不佳和线程竞争。

    多线程下的随机数

    如果更多线程主动生成具有相同Random的实例的新随机数,则上述情况发生的概率越高。对于生成许多(非常多)随机数的程序,不建议使用这种方式。在这种情况下,您应该使用ThreadLocalRandom,它在1.7版本中添加到Java中。ThreadLocalRandom扩展了Random并添加选项以限制其使用到相应的线程实例。为此,ThreadLocalRandom的实例保存在相应线程的内部映射中,并通过调用current()来返回对应的Random。使用方式如下:

    ThreadLocalRandom.current().nextInt()

    安全的随机数

    通过对Random的一些分析我们可以知道Random事实上是伪随机,是可以推导出规律的,而且依赖种子(seed)。如果我们搞抽奖或者其他一些对随机数敏感的场景时,用Random就不合适了,容易被人钻空子。JDK提供了SecureRandom来解决这个事情。SecureRandom是强随机数生成器,它可以产生高强度的随机数,产生高强度的随机数依赖两个重要的因素:种子和算法。算法是可以有很多的,通常如何选择种子是非常关键的因素。 Random的种子是System.currentTimeMillis(),所以它的随机数都是可预测的, 是弱伪随机数。强伪随机数的生成思路:收集计算机的各种信息,键盘输入时间,内存使用状态,硬盘空闲空间,IO延时,进程数量,线程数量等信息,CPU时钟,来得到一个近似随机的种子,主要是达到不可预测性。说的更通俗就是,使用加密算法生成很长的一个随机种子,让你无法猜测出种子,也就无法推导出随机序列数。

    总结

    今天我们探讨了业务中经常使用的随机数的一些机制和一些场景下的一些陷阱,希望你在使用随机数的时候能避免这种陷阱。

    关注微信公众号:码农小胖哥 获取更多干货

    展开全文
  • 在Web服务器上,许多线程正在向客户机提供内容。A/B测试是在网站上执行的,因此我们需要一个prng来为每个会话和测试选择一个变量。显然,当使用一个prng实例时,它是并发访问的,因此可能需要适当的锁定或其他机制。...

    在Web服务器上,许多线程正在向客户机提供内容。A/B测试是在网站上执行的,因此我们需要一个prng来为每个会话和测试选择一个变量。显然,当使用一个prng实例时,它是并发访问的,因此可能需要适当的锁定或其他机制。

    最初我们使用了java.util.Random(jur),但由于它存在上述缺陷,例如java.util.random有多好,所以我们尝试使用mersennetwester。然而,由于Mersenne Twister依赖于内部状态,因此性能下降,因此需要同步访问nextInt()。另一种选择可能是xor-shift prng,但它与mersenne twister有相同的问题。您可以在以下位置找到解释:http://xorshift.di.unimi.it/

    Random使用了compareAndset操作,该操作似乎更快,因为它不需要锁定,但根据javadoc类,它仍然不是线程安全的。相反,建议使用ThreadLocalRandom,这基本上会导致一个prng池。根据请求,一个随机可用线程处理https请求,因此从一组可用prng中选择一个随机prng。显然这非常快。

    从这样一个池中生成的随机数是否与从单个prng实例中生成的随机数一样好?

    另一种方法是使用单个prng实例从中预生成值流,例如使用ArrayBlockingQueue。

    哪种解决方案在性能方面更有效?

    对于这个应用程序(选择是否向用户显示a或b),只要随机数是均匀分布的,那么它们的质量实际上并不重要。

    您正在努力进行预优化。Random被记录为线程安全的,与Web应用程序所需的所有IO(数据库查询、HTTP请求等)相比,每次启动会话时调用NextBoolean()的性能完全可以忽略。

    在随机数质量方面,这个想法试图想出比java.util.random更好的方法。我们实际上有两个以上的变量,所以我们画整数。@亨利,就我所读到的,随机比特的概率分布不均匀。

    即便如此,随机性还是足够好的。但如果你想要一个完美的分布,你甚至不需要随机分布。只需使用一个atomicinteger,并在每个会话开始时递增它。然后计算变量数的模。你只需要一个好的分布,而不是一个好的随机性。

    但我的问题仍未得到解答。一个prng的池和一个prng一样好吗?

    @我喜欢你简单的想法。但是,这只在进行1/N拆分时有效。如果我想对两个变体进行60/40%的分割,我想这是行不通的。

    如果模5是0,1或2,选择版本A。如果是3或4,选择版本B。

    让我们在聊天中继续讨论。

    通过将结果传递给BlockingQueue,可以使任意随机数生成器线程安全。

    class SafeRandom implements Runnable {

    Random r = new Random();

    BlockingQueue q = new ArrayBlockingQueue<>(10);

    double get() throws InterruptedException {

    return q.take();

    }

    @Override

    public void run() {

    try {

    while (true) {

    q.put(r.nextDouble());

    }

    } catch (InterruptedException ie) {

    }

    }

    }

    为了避免同步问题,每个线程都有一个RNG。为了避免特定于线程的RNG给出相同的输出,让主RNG为特定于线程的RNG生成一系列初始种子。这可能需要向代码中传递一个额外的种子参数来生成一个新线程。

    您将需要测试自己在套件上运行RNG的不同选项的速度。如果需要,可以为主RNG和特定于线程的RNG使用不同的RNG引擎。一般来说,为特定于线程的RNG选择具有快速设置时间的RNG。这对主RNG来说并不重要,因为它只设置了一次。

    展开全文
  • Java】深入理解Java随机数

    千次阅读 2020-02-12 00:46:07
    本文介绍Java随机数的内容

    随机数

    根据密码学原理,随机数的随机性检验可以分为三个标准:

    • 统计学伪随机性。统计学伪随机性指的是在给定的随机比特流样本中,1的数量大致等于0的数量,同理,“10”“01”“00”“11”四者数量大致相等。类似的标准被称为统计学随机性。满足这类要求的数字在人类“一眼看上去”是随机的。
    • 密码学安全伪随机性。其定义为,给定随机样本的一部分和随机算法,不能有效的演算出随机样本的剩余部分。
    • 真随机性。其定义为随机样本不可重现。实际上只要给定边界条件,真随机数并不存在,可是如果产生一个真随机数样本的边界条件十分复杂且难以捕捉(比如计算机当地的本底辐射波动值),可以认为用这个方法演算出来了真随机数。

    相应的,随机数也分为三类:

    • 伪随机数:满足第一个条件的随机数。
    • 密码学安全的伪随机数:同时满足前两个条件的随机数。可以通过密码学安全伪随机数生成器计算得出。
    • 真随机数:同时满足三个条件的随机数。

    java.lang.Math.random()

    定义:public static double random()

    源码实现:

    public static double random() {
        return Math.RandomNumberGeneratorHolder.randomNumberGenerator.nextDouble();
    }
    
    private static final class RandomNumberGeneratorHolder {
    
        static final Random randomNumberGenerator = new Random();
    
        private RandomNumberGeneratorHolder() {}
        
    }
    

    根据源码分析得:

    java.lang.Math 类里有一个私有静态内部类,内有一个静态的 java.util.Random 类对象,调用其 nextDouble() 方法,生成 [0.0, 1.0) 范围内的伪随机浮点数。

    注意:使用的时候别忘了强转int或者long,除非需要的是浮点数。

    java.util.Random

    主要API:

    • protected int next​(int bits):生成下一个伪随机数。(注意protected,直接调用不了的)
    • public boolean nextBoolean():从此随机数生成器的序列中返回下一个伪随机、均匀分布的布尔值。
    • public void nextBytes​(byte[] bytes):生成随机字节并将其放入用户提供的字节数组中。
    • public double nextDouble():返回下一个伪随机数,它是此随机数生成器的序列中介于0.0和1.0之间的均匀分布的double值。
    • public float nextFloat():返回下一个伪随机数,此随机数生成器的序列在0.0和1.0之间均匀分布的float值。
    • public double nextGaussian():返回下一个伪随机数,与该随机数生成器的序列的 μ = 0.0 μ=0.0 μ=0.0 σ 2 = 1.0 σ^2=1.0 σ2=1.0 的高斯(“正态”)分布双精度值。
    • public int nextInt():返回下一个伪随机数,它是此随机数生成器序列中均匀分布的int值。
    • public int nextInt​(int bound):返回一个伪随机数,它从此随机数生成器的序列中提取,在0()和指定值(不含)之间均匀分布的int值。
    • public long nextLong():返回下一个伪随机数,该随机数是从此随机数生成器的序列中均匀分布的long值。

    通过new Random().nextInt(to-from)+from,输出两端的边界,就可以生成左闭右开区间的随机整数了。

    还可以自己借助循环逐位生成的大随机数:

    Random random = new Random();
    StringBuilder result = new StringBuilder();
    for (int i = 0; i < 9; i++) {
        result.append(random.nextInt(10));
    }
    System.out.println(Long.parseLong(result.toString()));
    

    Long.parseLong(result.toString())这步处理是为了消除先导0。

    或者一步到位:

    Random random = new Random();
    StringBuilder result = new StringBuilder();
    result.append(random.nextInt(9)+1);
    for (int i = 0; i < 8; i++) {
        result.append(random.nextInt(10));
    }
    System.out.println(Long.parseLong(result.toString()));
    

    对于 java.util.Random,JVM 通过传入的种子(seed)来确定生成随机数的区间。

    种子是一个数字,可称“种子值”,它为生成新的随机数提供了基础。
    只要种子值相同,获取的随机数的序列就是一致的,而且生成的结果都是可以预测的。

    这里seed对象的类型是 java.util.concurrent.AtomicLong,而不是简简单单的long。

    种子值还是可变的。

    public void setSeed​(long seed) 方法可生成随机数:

    public synchronized void setSeed(long seed) {
        this.seed.set(initialScramble(seed));
        this.haveNextNextGaussian = false;
    }
    

    调用的initialScramble():

    private static long initialScramble(long seed) {
        return (seed ^ 25214903917L) & 281474976710655L;
    }
    

    这是一种伪随机数的实现,而不是真正的随机数 。

    伪随机只是统计学上的概念,生成的伪随机数是有一定规律的,而这个规律出现的周期随着伪随机算法的优劣而不同。一般来说这个“周期”比较长,但是也是可以预测的。

    再看看next(int bits)方法的源码:

    protected int next(int bits) {
        AtomicLong seed = this.seed;
        long oldseed;
        long nextseed;
        do {
            oldseed = seed.get();
            nextseed = oldseed * 25214903917L + 11L & 281474976710655L;
        } while(!seed.compareAndSet(oldseed, nextseed));
        return (int)(nextseed >>> 48 - bits);
    }
    

    Random 类是线程安全的,根据 next(int bits) 还有seed的属性,可以看出其内部使用 CAS 来保证线程安全性。

    一般而言,CAS 相比加锁有一定的优势(参考“乐观锁”),但并不一定意味着高效
    我们可以在每次使用 Random 时都去 new 一个新的线程私有化的 Random 对象。在不同线程上并发使用相同的Random实例可能会导致争用,从而导致性能不佳,问题源于使用种子来生成随机数。

    首先,旧种子和新种子存储在两个辅助变量上。在这一点上,创造新种子的规则并不重要。

    要保存新种子,使用 compareAndSet() 方法将旧种子替换为下一个新种子,但这仅仅在旧种子对应于当前设置的种子的条件下才会触发。

    如果此时的值由并发线程操纵,则该方法返回false,这意味着旧值与例外值不匹配。因为是循环内进行的操作,那么会发生自旋,直到变量与例外值匹配。这可能会导致性能不佳和线程竞争。

    使用 java.lang.ThreadLocal 来维护线程私有化对象 以及 使用java.util.concurrent.ThreadLocalRandom 都更适合于多线程并发环境。

    java.util.concurrent.ThreadLocalRandom

    ThreadLocalRandom是隔离到当前线程的随机数生成器。

    像Math类使用的全局Random生成器一样,ThreadLocalRandom会使用内部生成的种子进行初始化,否则无法进行修改。

    ThreadLocalRandom 继承了Random并添加选项以限制其使用到相应的线程实例。为此,ThreadLocalRandom的实例保存在相应线程的内部映射中,并通过调用current()来返回对应的Random。

    如果适用的话,在并发程序中使用ThreadLocalRandom而不是共享Random对象通常会遇到更少的开销和竞争。

    当多个任务(例如,每个ForkJoinTask)在线程池中并行使用随机数时,使用ThreadLocalRandom特别合适。

    ThreadLocalRandom的构造器是private的:

    private ThreadLocalRandom() {}
    

    获取对象要调用current():

    public static ThreadLocalRandom current() {
        if (U.getInt(Thread.currentThread(), PROBE) == 0) {
            localInit();
        }
    
        return instance;
    }
    

    当所有用法都是这种形式时,永远不可能在多个线程之间意外地共享ThreadLocalRandom。

    调用方法:

    ThreadLocalRandom.current().nextX()
    

    nextX()包括nextBoolean()、nextDouble()、nextFloat()、nextInt()、nextLong()等……

    例如:

    ThreadLocalRandom.current().nextInt()
    

    ThreadLocalRandom的实例不是加密安全的,还是普通的“伪随机数”。考虑在对安全敏感的应用程序中使用SecureRandom。此外,除非系统属性java.util.secureRandomSeed设置为true,否则默认构造的实例不会使用加密的随机种子。

    java.security.SecureRandom

    通过对Random的一些分析我们可以知道Random事实上是伪随机,是可以推导出规律的,而且依赖种子(seed)。如果抽奖或者其他一些对随机数敏感的场景时,用Random不合适。JDK提供了 java.security.SecureRandom 来解决问题。

    SecureRandom提供了加密功能强的随机数生成器(RNG)。

    加密强度高的随机数至少要符合FIPS 140-2“加密模块的安全性要求”第4.9.1节中指定的统计随机数生成器测试。此外,SecureRandom必须产生不确定的输出。因此,传递给SecureRandom对象的任何种子材料都必须不可预测,并且所有SecureRandom输出序列必须具有加密强度,如RFC 4086:安全性的随机性要求中所述。

    许多SecureRandom实现采用伪随机数生成器(PRNG,也称为确定性随机位生成器或DRBG)的形式,这意味着它们使用确定性算法从随机种子生成伪随机序列。其他实现可以产生真正的随机数,而其他实现则可以使用两种技术的组合。

    SecureRandom是强随机数生成器,它可以产生高强度的随机数,产生高强度的随机数依赖两个重要的因素:种子算法。算法是可以有很多的,通常如何选择种子是非常关键的因素。
    Random的种子是 System.currentTimeMillis(),所以它的随机数都是可预测的, 是弱伪随机数。

    强伪随机数的生成思路:收集计算机的各种信息,键盘输入时间,内存使用状态,硬盘空闲空间,IO延时,进程数量,线程数量等信息,CPU时钟,来得到一个近似随机的种子,主要是达到不可预测性

    说的更通俗就是,使用加密算法生成很长的一个随机种子,让人无法猜测出种子,也就无法推导出随机序列数。

    调用者通过无参数构造函数或getInstance方法之一获取SecureRandom实例。

    例如:

    • SecureRandom r1 = new SecureRandom();
    • SecureRandom r2 = SecureRandom.getInstance("NativePRNG");
    • SecureRandom r3 = SecureRandom.getInstance("DRBG", DrbgParameters.instantiation(128, RESEED_ONLY, null));

    上面的第三条语句返回支持特定实例化参数的特定算法的SecureRandom对象。实现的有效实例化参数必须匹配此最小请求,但不一定相同。例如,即使请求不需要某个功能,实际的实例也可以提供该功能。一个实现可以延迟地实例化SecureRandom,直到它被实际使用为止,但是有效的实例化参数必须在创建后立即确定,并且getParameters() 始终应返回不变的相同结果。

    SecureRandom的典型调用者调用以下方法来检索随机字节:

    • SecureRandom random = new SecureRandom();
    • byte[] bytes = new byte[20];
    • random.nextBytes(bytes);

    调用者还可以调用generateSeed(int)方法来生成给定数量的种子字节(例如,为其他随机数生成器提供种子):byte[] seed = random.generateSeed(20);

    不播种新创建的PRNG SecureRandom对象(除非它是由SecureRandom(byte [])创建的)。对nextBytes的首次调用将强制其从实现特定的熵源中播种自身。如果先前调用过setSeed,则不会发生这种自我播种。

    通过调用reseed或setSeed方法,可以随时重新播种SecureRandom。重新设定种子的方法从其熵源读取熵输入以重新设定其自身的种子。 setSeed方法要求调用者提供种子。

    请注意,并非所有SecureRandom实施都支持种子

    一些SecureRandom实现可能在其nextBytes(byte [],SecureRandomParameters)reseed(SecureRandomParameters)方法中接受SecureRandomParameters参数,以进一步控制这些方法的行为。

    注意:根据实现的不同,例如,在各种类Unix操作系统上,如果熵源是/dev/random,则在收集熵时,generateSeed、reseed、nextBytes方法可能会阻塞。

    SecureRandom对象可安全用于多个并发线程。

    通过在注册提供程序时将服务提供程序属性“ ThreadSafe”设置为“ true”,SecureRandom服务提供程序可以公告它是线程安全的。 否则,此类将改为同步对SecureRandomSpi实现的以下方法的访问:

    • SecureRandomSpi.engineSetSeed(byte[])
    • SecureRandomSpi.engineNextBytes(byte[])
    • SecureRandomSpi.engineNextBytes(byte[], SecureRandomParameters)
    • SecureRandomSpi.engineGenerateSeed(int)
    • SecureRandomSpi.engineReseed(SecureRandomParameters)

    System.currentTimeMillis()

    可以用System.currentTimeMillis()生成随机数:

    利用System.currentTimeMillis(),获取从1970年1月1日0时0分0秒(这与UNIX系统有关,Java就这么搞的)到此刻的一个long型的毫秒数,取模之后即可得到所需范围内的随机数。

    int max=100,min=1;
    long randomNum = System.currentTimeMillis();  
    int ran3 = (int) (randomNum%(max-min)+min);  
    System.out.println(ran3);
    
    展开全文
  • 原标题:多线程环境下生成随机数编译:ImportNew - 李广 ,生成伪随机数据Java里有伪随机型和安全型两种随机数生成器。伪随机生成器根据特定公式将seed转换成新的伪随机数据的一部分。安全随机生成器在底层依赖到...
  • 做游戏后台的,就避免不了生成随机数,随机物品给玩家...它是一个线程安全类,理论上可以通过它同时在多个线程中获得互不相同的随机数。这样的线程安全是通过AtomicLong实现的。 Random 使用 AtomicLong CAS (c...
  • 主要介绍了Java随机数的几种实现方式,从最简单的Math.random到多线程的并发实现都在本文所列之中,需要的朋友可以参考下
  • java生成随机数

    2021-12-13 14:28:56
    想写个小Demo,需要大量测试数据,就想到了随机数,但是在Random类和Math.random()上犯迷糊了,就整理一下,以供以后参考。 Random类解释: 用于生成一个伪随机数,所谓伪随机数,就是只要种子一样,获得的随机数...
  • java8流源码 更随意。 更短的时间。 仍然是 java.util.Random 的一个实例。 BetterRandom 是一个库,可帮助您从伪随机数生成器 (PRNG) 及其种子源中获得最佳性能和最佳伪随机性。 有了它,您可以: 将具有改进的速度...
  • 线程随机数

    千次阅读 2019-05-18 16:32:14
    在JDK7之前java.util.Random是使用比较广泛的随机数生成工具类,另外java.lang.Math中的随机数生成也是使用的java.util.Random的实例。下面先看看java.util.Random的使用: public class RandomTest { public ...
  • java基础之多线程2

    2021-03-10 01:00:17
    第二节 线程的定义和创建2.1 线程定义和创建2:实现Runnable接口【示例2】使用多线程实现龟兔赛跑2public class TortoiseRunnable implements Runnable {//private int num = 100; /*** 线程体,线程要执行的任务*/@...
  • Java获取随机数的实现方法

    千次阅读 2021-07-30 11:18:53
    在实际开发工作中经常需要用到随机数。...这就是利用随机数的原理。总之随机数在日常开发工作中经常用到。...在Java语言中生成随机数相对来说比较简单,因为有一个现成的方法可以使用。在Math类中,Java语言提供了一个
  • 每一个线程有一个独立的随机数生成器,用于并发产生随机数,能够解决多个线程发生的竞争争夺。效率更高! ThreadLocalRandom 不是直接用 new 实例化,而是第一次使用其静态方法 current() 得到 ThreadLocal ...
  • java随机数

    2012-11-13 14:39:13
    幸运的是,java.util.Random是线程安全的,所以不存在多个线程调用会破坏种子(seed)的风险。 另一个值得考虑的是多线程java.lang.ThreadLocal的实例。偷懒的做法是通过Java本身API实现单一实例,当然你也可以确保每...
  • 在一个多线程程序中,如果需要生成随机数,应该使用 java se7 中新增的 java.util.concurrent.ThreadLoaclRandom 类 ,避免了 使用 java.util.Random 对象可能带来的竞争问题,可以获得更佳的性能。 《深入理解java...
  • Java创建安全随机数

    2021-05-18 11:57:25
    public String secureRandom(int length) { byte[] bytes = new byte[length]; SecureRandom secureRandom = new SecureRandom(); secureRandom.nextBytes(bytes); StringBuilder builderByte = new ...
  • 本文实例为大家分享了java用多线程找出最大随机数的具体代码,供大家参考,具体内容如下问题: 系统随机生成 10000 个数,构造 5 个线程并利用它们的 Join 方法计算这些随机数的最大值。思路:1)、定义一个全局变量...
  • 原标题:Java 生成随机数的 N 种方法...2.Java APIJava API 提供了几种随机数生成方法。让我们一起来了解一下。2.1.java.lang.MathMath 类中的 random 方法返回一个 [0.0, 1.0) 区间的 double...
  • Java 中,生成随机数的场景有很多,所以本文我们就来盘点一下 4 种生成随机数的方式,以及它们之间的区别和每种生成方式所对应的场景。 1.Random Random 类诞生于 JDK 1.0,它产生的随机数是伪随机数,也就是有...
  • JAVA随机数

    2021-02-27 11:32:06
    《望岳三首·其二》- 唐代 - 杜甫获取随机数的方式经常使用的大概就下面5种①Math.random(): 获取随机小数范围:[0.0,1.0) 返回的值是double类型②Random类构造方法:Random() : 建议使用无参构造方法方法:int ...
  • private static final ...此类在 JDK7 中引人,它使得每个线程都可以有自己的随机数生成器。 我们要避免 Random 实例被多线程使用,虽然共享该实例是线程安全的,但会因竞争同一 seed 而导致性能下降。 ...
  • JAVA生成随机数

    万次阅读 2018-07-17 13:47:13
    随机数Int的生成 生成无边界的Int @Test public void testRandom_generatingIntegerUnbounded() throws Exception { int intUnbounded = new Random().nextInt(); System.out.println(intUnbounded); } 生成...
  • 简介在 JDK7 中,java.util.concurrent 包含了一个相当便利的类随机数生成类 ThreadLocalRandom,当应用程序期望在多个线程或 ForkJoinTasks 中使用随机数时。对于并发访问,使用 ...
  • JAVA产生随机数

    2020-04-29 23:22:33
    // 通过本地线程产生随机数,可以仔细研究ThreadLocal的用法。 ThreadLocalRandom.current().nextInt(10) 据说可以在高并发下产生随机数,没有测试过,不过代码简洁,我还是喜欢用这个方法来生成随机数。 2、可以...
  • Java中生成随机数的实现方法总结

    千次阅读 2021-02-12 09:17:03
    在实际开发工作中经常需要用到随机数。...这就是利用随机数的原理。总之随机数在日常开发工作中经常用到。...笔者这里就以Java语言为例,谈谈随机数生成的方法以及一些技巧。一、利用random方法来生成随机数。 ...
  • Java生成随机数我总共总结了5种方式: (一)Math.random()静态方法: 产生的随机数是0-1之间的一个double,0<=random<=1 使用: for(int i=0;i<10;i++) { System.out.println(Math.println()); } 实现...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 33,069
精华内容 13,227
关键字:

java线程随机数

java 订阅