Параллелизм Java: выполнение многих бесконечных задач с несколькими потоками

Самым большим убийцей производительности, вероятно, будут проверки безопасности потоков, которые вы выполняете, чтобы убедиться, что все частицы взаимодействуют безопасным образом. Я предлагаю вам использовать один поток на ядро ​​и попытаться свести к минимуму взаимодействие между потоками. Это можно сделать, разделив ваше пространство на потоки, например. половина X, половина Y, половина Z делит пространство на 8. Вы можете смотреть на все взаимодействия в каждом пространстве одновременно и независимо, и вам нужно только беспокоиться, когда частица переходит из одного пространства/потока в другое.

Я бы предположил, что вы храните все свои частицы, возможно, в массиве двумерного массива? Это был бы отличный кандидат для Fork-Join Framework.

Вы бы разделили вычисление частей массива на более мелкие части. Вы продолжаете разделять до определенного размера. Наконец вы вычисляете и возвращаетесь. Затем возвращаемое значение будет объединено и рассчитано с другой стороной дерева.

Вместо потока на частицу я бы создал ExecutorService с соответствующим количеством потоков. Я бы сохранил частицы в списке (или в коллекции какого-либо другого типа). Я бы создал отдельные части работы, которые будут выполняться (либо как Runnable, либо как Callable) для каждого шага расчета и обновления частиц. Когда вы отправляете часть работы исполнителю, вы получаете обратно Future. Поместите эти фьючерсы в коллекцию. После того, как вы отправили все части работы, которые хотите выполнять параллельно, вы перебираете свой список фьючерсов и вызываете get() для каждого из них, чтобы реализовать шаги синхронизации.

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

Для каждой частицы вы называете calculateNetForce(allTheParticles), что, как я полагаю, делает ваши вычисления пропорциональными O(N^2) (квадрату числа всех частиц). Это главный убийца производительности, и вам лучше найти алгоритм со сложностью O(N), а уже потом пытаться распараллелить. Навскидку могу предложить сначала вычислить суммарную массу и центр тяжести для всех частиц. Затем для каждой частицы рассчитайте массу и центр остальных частиц. Это можно сделать, взяв общую массу и центр и добавив «дырку» с отрицательной массой вместо текущей частицы. Затем вычислите силу между частицей и остальными. Вычисления для каждой частицы независимы и могут быть распараллелены любым из способов, предложенных другими комментаторами.

Почему бы вам не делать расчеты дискретными шагами?

while(true){


for(Particle p : allParticles){
   force = p.calculateNetForce(allParticles);   
   p.setNextPosition(force); //Remembers, but doesn't change the current position
}

for(Particle p : allParticles){
    p.nextState(); //Change the position
}

}

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

ОБНОВЛЕНИЕ ЯВА 8

Используя Java 8, вы можете воспользоваться преимуществами многоядерных систем, не заботясь о потоках, синхронизации и т. д.

 while(true){
       allParticles.parallelStream().forEach(p -> {
           double force = p.calculateNetForce(allParticles);
           p.setNextPosition(force)
       });

       allParticles.parallelStream().forEach(p ->   p.nextState());      
 }

Частица сама должна быть Runnable и Callable, это позволит вам не создавать много лишних объектов и синхронизировать разные шаги. Вот SSCCEE:

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Particle implements Callable<Void> {

  private enum ParticleState {
    POSITION_UPDATED, FORCE_CALCULATED
  }

  private int id;
  private int calculatedForce;
  private ParticleState particleState = ParticleState.POSITION_UPDATED;
  private List<Particle> allTheParticles;

  public Particle(int id, List<Particle> allTheParticles) {
    this.id = id;
    this.allTheParticles = allTheParticles;
  }

  private void calculateNetForce() {
    System.out.println("calculation in " + id);
    String someIntenseOperation = "";
    for (int i = 0; i < 10000; i++) {
      someIntenseOperation += allTheParticles.size();
    }
    calculatedForce = 0;
    particleState = ParticleState.FORCE_CALCULATED;
  }

  private void updatePosition() {
    System.out.println("updating position of " + id);
    particleState = ParticleState.POSITION_UPDATED;
  }

  @Override
  public Void call() throws Exception {
    switch (particleState) {
      case FORCE_CALCULATED:
        updatePosition();
        break;
      case POSITION_UPDATED:
        calculateNetForce();
        break;
    }
    return null;
  }

  public static void main(String[] args) throws InterruptedException {
    final ExecutorService executor = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors() + 1);
    final List<Particle> allTheParticles = new ArrayList<>();
    for (int i = 0; i < 20; i++) {
      allTheParticles.add(new Particle(i, allTheParticles));
    }
    while (true) {
      executor.invokeAll(allTheParticles);
      executor.invokeAll(allTheParticles);
    }
  }
}

Поскольку для проверки столкновений обычно требуется n^2 вычислений, разделение пространства является хорошей идеей. хотя, по сути, это будет проблема O (n ^ 2).

Эта проблема плохо подходит для матричного приближения (но загляните в раздел Параллельные вычисления, чтобы узнать о лучших решениях). идеи, чтобы справиться с этим) Вы можете использовать некоторые методы, указанные здесь: способ симулировать много столкновений частиц?

Обратите внимание, что использовать модель Актера не рекомендуется, поскольку потоки будут проблематичными после определенного количество.

Теперь есть Java OpenCL lib (например: Aparapi), а Java 9 должна включать openCL с Sumatra. проект. Таким образом, вы можете использовать библиотеку Fork and Join, а JVM будет использовать OpenCL под капотом.