如何通过 ThreadLocalRandom 解决多线程环境下对传统 Random 实例的竞争损耗

在多线程编程中，生成随机数是常见需求，很多开发者会直接使用Random类来实现，但在高并发场景下，这种方式往往会带来性能问题。传统Random实例在多线程共享使用时，会因为内部同步机制产生明显的竞争损耗，而ThreadLocalRandom正是为解决这一问题而设计的工具类。

传统Random的多线程竞争问题

Random类的随机数生成依赖于一个种子值，每次生成随机数时都会更新这个种子。当多个线程同时操作同一个Random实例时，为了保证种子更新的线程安全，Random内部使用了AtomicLong来保存种子，并通过CAS操作更新种子值。

在并发量较高的情况下，大量线程会同时竞争同一个原子变量的更新权，CAS操作失败后会不断重试，这就产生了额外的性能损耗，也就是我们所说的竞争损耗。

我们可以通过一段简单的测试代码来验证这个现象：

import java.util.Random;
import java.util.concurrent.CountDownLatch;

public class RandomTest {
    private static final Random random = new Random();
    private static final int THREAD_COUNT = 10;
    private static final int LOOP_COUNT = 100000;

    public static void main(String[] args) throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(THREAD_COUNT);
        long start = System.currentTimeMillis();
        for (int i = 0; i < THREAD_COUNT; i++) {
            new Thread(() -> {
                for (int j = 0; j < LOOP_COUNT; j++) {
                    random.nextInt();
                }
                latch.countDown();
            }).start();
        }
        latch.await();
        long end = System.currentTimeMillis();
        System.out.println("传统Random耗时：" + (end - start) + "ms");
    }
}

ThreadLocalRandom的实现原理

ThreadLocalRandom继承自Random，它的核心设计思路是让每个线程都拥有自己独立的随机数生成种子，这样就不需要多个线程竞争同一个种子变量，从根源上避免了竞争损耗。

ThreadLocalRandom的实现依赖线程本地变量，每个线程的种子值都存储在自己的线程本地内存中，线程在生成随机数时只需要操作自己的本地种子，不需要和其他线程产生同步交互。它的种子初始化和更新逻辑都封装在类内部，开发者不需要手动维护种子状态。

ThreadLocalRandom的使用方式

ThreadLocalRandom的使用非常简单，不需要像传统Random那样创建实例，直接通过静态方法获取当前线程对应的ThreadLocalRandom实例即可。

常用的API如下：

• ThreadLocalRandom.current()：获取当前线程的ThreadLocalRandom实例
• nextInt()：生成随机int值
• nextInt(int bound)：生成0到bound-1之间的随机int值
• nextLong()：生成随机long值
• nextDouble()：生成0.0到1.0之间的随机double值

下面是使用ThreadLocalRandom的示例代码：

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ThreadLocalRandom;

public class ThreadLocalRandomTest {
    private static final int THREAD_COUNT = 10;
    private static final int LOOP_COUNT = 100000;

    public static void main(String[] args) throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(THREAD_COUNT);
        long start = System.currentTimeMillis();
        for (int i = 0; i < THREAD_COUNT; i++) {
            new Thread(() -> {
                for (int j = 0; j < LOOP_COUNT; j++) {
                    // 获取当前线程的ThreadLocalRandom实例并生成随机数
                    ThreadLocalRandom.current().nextInt();
                }
                latch.countDown();
            }).start();
        }
        latch.await();
        long end = System.currentTimeMillis();
        System.out.println("ThreadLocalRandom耗时：" + (end - start) + "ms");
    }
}

两种方式的性能对比

我们可以将上面的两段测试代码在相同环境下运行，假设线程数为10，每个线程生成10万次随机数，通常可以得到类似如下的对比结果：

从对比结果可以明显看出，在多线程场景下，ThreadLocalRandom的性能要远优于传统Random，随着并发线程数的增加，这种性能优势会更加明显。

使用注意事项

虽然ThreadLocalRandom适合多线程场景，但也需要注意使用规范：

• 不要在多线程场景下共享同一个Random实例，否则还是会产生竞争损耗
• ThreadLocalRandom不需要手动创建实例，直接通过ThreadLocalRandom.current()获取即可，不需要缓存实例
• 单线程场景下如果不需要并发支持，使用传统Random即可，两者的单线程性能差异很小
• ThreadLocalRandom是线程绑定的，不能跨线程传递使用，每个线程只能使用自己的实例

总的来说，在多线程环境下生成随机数时，优先选择ThreadLocalRandom可以有效避免传统Random的竞争损耗，提升程序的并发性能。

ThreadLocalRandomRandom多线程竞争损耗修改时间：2026-07-17 19:39:24