Высокопроизводительная буферизация для потока рандов

Это более эффективно, чем использование очереди, потому что;

• полезная нагрузка представляет собой массив double[], что означает, что фоновый поток может генерировать больше данных, прежде чем передавать их.
• все объекты перерабатываются.

.

public class RandomGenerator {
    private final ExecutorService generator = Executors.newSingleThreadExecutor(new ThreadFactory() {
        @Override
        public Thread newThread(Runnable r) {
            Thread t = new Thread(r, "generator");
            t.setDaemon(true);
            return t;
        }
    });
    private final Exchanger<double[][]> exchanger = new Exchanger<>();
    private double[][] buffer;
    private int nextRow = Integer.MAX_VALUE;

    public RandomGenerator(final int rows, final int columns) {
        buffer = new double[rows][columns];
        generator.submit(new Callable<Void>() {
            @Override
            public Void call() throws Exception {
                Random random = new Random();
                double[][] buffer2 = new double[rows][columns];
                while (!Thread.interrupted()) {
                    for (int r = 0; r < rows; r++)
                        for (int c = 0; c < columns; c++)
                            buffer2[r][c] = random.nextGaussian();
                    buffer2 = exchanger.exchange(buffer2);
                }
                return null;
            }
        });
    }

    public double[] nextArray() throws InterruptedException {
        if (nextRow >= buffer.length) {
            buffer = exchanger.exchange(buffer);
            nextRow = 0;
        }
        return buffer[nextRow++];
    }
}

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

как справиться с общим случаем параллельной генерации больших потоков небольших независимых примитивов и их потребления из одного потока.

Я бы использовал Exchanger<double[][]> для заполнения значения в фоновом режиме, так как они эффективно передаются (без больших накладных расходов GC)

Проблема с вашей производительностью, по-видимому, заключается в том, что отдельные задания слишком малы, поэтому большая часть времени тратится на синхронизацию и постановку в очередь самих заданий. Следует учитывать одну вещь: не генерировать большой поток небольших заданий, а доставлять каждому рабочему потоку набор заданий среднего размера, который он будет комментировать ответом.

Например, вместо повторения вашего цикла с первым потоком, выполняющим итерацию № 0, следующим потоком, выполняющим итерацию № 1, ... я бы сделал первый поток, выполняющий итерации с № 0 до № 999 или что-то в этом роде. Они должны работать независимо и аннотировать класс Job ответом своих вычислений. Затем в конце они могут вернуть всю коллекцию заданий, которые были завершены как Future.

Ваш класс Job может выглядеть примерно так:

public class Job {
    Collection<RealVector> dataCollection;
    Collection<SomeAnswer> answerCollection = new ArrayList<SomeAnswer>();
    public void run() {
        for (RealVector d : dataCollection) {
           // do the magic work on the vector
           while(!converged){
              ...
           }
           // put the associated "answer" in another collection
           answerCollection.add(someAnswer);
        }
    }
}