具有低代价任务的顺序和并行计算的性能

Question

我有一个表示当前状态对象“cell”列表。

list currentCells=new arraylist ()；

列表 >futures=TaskExecutor.InvokeAll（cells）；

我知道并行解决一个问题总是需要一个开销。在这种情况下，它在我的循环中加速。你能推荐什么方法来加速我的循环？

Answer 1

如果我将numberOfThreads从1更改为12（我最多有12个处理器），速度似乎不会有任何差别。我的循环的代码是：

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

import view.ConsolePrinter;

public class Engine implements Runnable {

    private int numberOfThreads = 8;
    private boolean shouldRun = false;
    private ExecutorService taskExecutor;
    private Thread loopThread;
    private List<Cell> cells;
    private World world;
    private int numberOfRunningTimeSteps = 0;
    private int FPS = 30;
    private double averageFPS;

    public Engine(List<Cell> cells, World world) {
        this.cells = cells;
        taskExecutor = Executors.newFixedThreadPool(numberOfThreads);
        this.world = world;
    }

    @Override
    public void run() {

        world.resetTime();
        shouldRun = true;

        long startTime;
        long estimatedTimeMillis;
        long waitTime;
        long totalTime = 0;
        long targetTime = 1000 / FPS;

        int frameCount = 0;
        int maxFrameCount = 1; 

        while (shouldRun) {

            startTime = System.nanoTime();

            try {
                List<Future<Cell>> futures = taskExecutor.invokeAll(cells);
                List<Cell> futureCells = new ArrayList<Cell>();

                futures.forEach((future) -> {
                    try {
                        futureCells.add(future.get());
                    } catch (InterruptedException | ExecutionException e) {
                        e.printStackTrace();
                    }

                });

                world.setCells(futureCells);

            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            world.timeProceeded();

            if (numberOfRunningTimeSteps != 0 && world.getTime() == numberOfRunningTimeSteps) {
                shouldRun = false;
            }

            estimatedTimeMillis = (System.nanoTime() - startTime) / 1000000;
            waitTime = targetTime - estimatedTimeMillis;
            try {
                if (waitTime > 0.0) {
                    Thread.sleep(waitTime);
                }

            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            totalTime += System.nanoTime() - startTime;
            frameCount++;
            if (frameCount == maxFrameCount) {
                averageFPS = 1000.0 / ((totalTime / frameCount) / 1000000);

                frameCount = 0;
                totalTime = 0;
            }
        }

    }

    public void start(int n) {
        loopThread = new Thread(this);
        loopThread.start();
        numberOfRunningTimeSteps = n;
    }

    public void stop() {
        shouldRun = false;

    }

}