Java for Beginner

[Совет по Java #011]

Тема: Random — потоконебезопасный и медленный для многопоточки. Используйте ThreadLocalRandom для параллельных потоков.

Проблема: Класс java.util.Random в целом является потокобезопасным, но его безопасность достигается за счет внутренней синхронизации (атомарного обновления seed'а через CAS-операции в современных реализациях).

В высококонкурентной среде это создает конкуренцию за общий ресурс — несколько потоков пытаются обновить одно и то же состояние, что приводит к кеш-промахам, простоям и значительному падению производительности. Кроме того, использование одного экземпляра Random несколькими потоками может привести к предсказуемости генерации (если seed обновляется неатомарно в старых версиях) или просто к узкому месту.

Решение: Для многопоточных сценариев предназначен класс java.util.concurrent.ThreadLocalRandom.

Он использует технику ThreadLocal: каждый поток получает свой собственный экземпляр генератора с собственным seed'ом, что полностью устраняет конкуренцию. Метод ThreadLocalRandom.current() возвращает генератор, привязанный к текущему потоку, без создания новых объектов при каждом вызове.

Это не только потокобезопасно, но и значительно быстрее в многопоточной среде (ускорение может достигать десятков раз).

import java.util.*;
import java.util.concurrent.*;

public class RandomExample {
    
    private static final Random SHARED_RANDOM = new Random();
    
    //Антипаттерн: общий Random в многопоточке
    public static class BadTask implements Callable<Integer> {
        @Override
        public Integer call() {
            // Конкуренция за общий Random
            return SHARED_RANDOM.nextInt(100);
        }
    }
    
    //Правильно: ThreadLocalRandom
    public static class GoodTask implements Callable<Integer> {
        @Override
        public Integer call() {
            // Каждый поток использует свой генератор
            return ThreadLocalRandom.current().nextInt(100);
        }
    }
    
    //Антипаттерн: создание Random в каждом потоке
    public static class WastefulTask implements Callable<Integer> {
        @Override
        public Integer call() {
            // Новый объект при каждом вызове — лишняя аллокация
            return new Random().nextInt(100);
        }
    }
    
    // Демонстрация производительности
    public static void main(String[] args) throws Exception {
        int threads = 10;
        int tasksPerThread = 100000;
        
        ExecutorService executor = Executors.newFixedThreadPool(threads);
        
        // Плохой вариант
        long start = System.nanoTime();
        List<Callable<Integer>> badTasks = Collections.nCopies(threads * tasksPerThread, new BadTask());
        executor.invokeAll(badTasks);
        long end = System.nanoTime();
        System.out.println("Shared Random: " + TimeUnit.NANOSECONDS.toMillis(end - start) + " ms");
        
        // Хороший вариант
        start = System.nanoTime();
        List<Callable<Integer>> goodTasks = Collections.nCopies(threads * tasksPerThread, new GoodTask());
        executor.invokeAll(goodTasks);
        end = System.nanoTime();
        System.out.println("ThreadLocalRandom: " + TimeUnit.NANOSECONDS.toMillis(end - start) + " ms");
        
        executor.shutdown();
    }
}

Объяснение: ThreadLocalRandom использует более быстрый алгоритм генерации (на основе смешивания) по сравнению с классическим Random.

Важно вызывать именно ThreadLocalRandom.current() при каждой операции генерации — это дешевый вызов, возвращающий ссылку на генератор текущего потока, а не создающий новый объект. Для однопоточных сценариев разница между Random и ThreadLocalRandom незначительна, но в многопоточных ThreadLocalRandom всегда предпочтительнее.

В Java 8+ появился также класс SplittableRandom для параллельных stream'ов и fork/join пулов, который еще быстрее, если задача может быть разделена на независимые подзадачи.

#Java #советы

🔥4👍2

111 views08:59