Question

我有这个程序（矩阵的乘法不重要得到结果）：

package serie06_ExecutorFramework;

import java.util.Random;

public class Sequenziale {
    public static final int NUM_OPERATIONS = 100000;
    public static final int MATRIX_SIZE = 64;

    public static void main(final String[] args) {
        final Random rand = new Random();
        System.out.println("Simulazione iniziata");
        for (int operation = 0; operation < NUM_OPERATIONS; operation++) {
            // Crea matrici
            final int[][] m0 = new int[MATRIX_SIZE][MATRIX_SIZE];
            final int[][] m1 = new int[MATRIX_SIZE][MATRIX_SIZE];
            final int[][] m2 = new int[MATRIX_SIZE][MATRIX_SIZE];

            // Inizializza gli array con numeri random
            for (int i = 0; i < MATRIX_SIZE; i++)
                for (int j = 0; j < MATRIX_SIZE; j++) {
                    m0[i][j] = rand.nextInt(10);
                    m1[i][j] = rand.nextInt(10);
                }

            // Moltiplica matrici
            for (int i = 0; i < m0[0].length; i++)
                for (int j = 0; j < m1.length; j++)
                    for (int k = 0; k < m0.length; k++)
                        m2[i][j] += m0[i][k] * m1[k][j];
        }
        System.out.println("Simulazione terminata");
    }
}

到一个与该任务一起工作并使用多核的程序，最后我必须绘制程序的加速程序

加速=顺序时间/平行时间

我用这种方式做了这个程序：
任务

package pcepS6;

import java.util.Random;

public class MatrixMoltiplication implements Runnable {
    private final int[][] m0;
    private final int[][] m1;

    public MatrixMoltiplication(int[][] m0, int[][] m1) {
        this.m0 = m0;
        this.m1 = m1;
    }

    @Override
    public void run() {
        final Random rand = new Random();
        // Inizializza gli array con numeri random
        for (int i = 0; i < S6Esercizio1.MATRIX_SIZE; i++)
            for (int j = 0; j < S6Esercizio1.MATRIX_SIZE; j++) {
                m0[i][j] = rand.nextInt(10);
                m1[i][j] = rand.nextInt(10);
            }

        // Moltiplica matrici
        final int[][] m2 = new int[m0.length][m1.length];
        for (int i = 0; i < m0[0].length; i++)
            for (int j = 0; j < m1.length; j++)
                for (int k = 0; k < m0.length; k++)
                     m2[i][j] += m0[i][k] * m1[k][j];
    }
}

主要

package pcepS6;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class S6Esercizio1 {
    public static final int NUM_OPERATIONS      = 100000;
    public static final int MATRIX_SIZE         = 64;
    private static int numThreads               = 5;
    private static final ExecutorService myExec = Executors.newFixedThreadPool(numThreads);


    public static void main(final String[] args) {

        System.out.println("Simulazione iniziata");
        System.out.println("Submit delle tasks ai threads");

        for (int operation=0; operation<NUM_OPERATIONS; operation++) {
            int[][] a = new int[MATRIX_SIZE][MATRIX_SIZE];
            int[][] b = new int[MATRIX_SIZE][MATRIX_SIZE];
            myExec.execute( new MatrixMoltiplication(a, b) );
        }

        //l'executor non accetta piu nessuna ulteriore tasks
        myExec.shutdown();
        System.out.println("Tutte le tasks sono state inviate ai threads");

        while ( !myExec.isTerminated() ) {}
        System.out.println("Tutti i threads hanno finito");

    }
}

问题是我不能只使用1个线程来获取执行时间，在2个线程获得新时间之后......直到20个线程，所以最后总是计划加速。
我不能这样做，因为如果我使用少量线程，我有这个错误：

Exception in thread "main" java.lang.OutOfMemoryError: GC overhead
limit exceeded  at pcepS6.S6Esercizio1.main(S6Esercizio1.java:39)
Exception in thread "pool-1-thread-6" java.lang.OutOfMemoryError: GC
overhead limit exceeded     at
pcepS6.MatrixMoltiplication.run(MatrixMoltiplication.java:25)   at
java.util.concurrent.ThreadPoolExecutor.runWorker(Unknown Source)   at
java.util.concurrent.ThreadPoolExecutor$Worker.run(Unknown Source)  at
java.lang.Thread.run(Unknown Source)

我知道我可以使用 Executors.newFixedThreadPool 方法 newCachedThreadPool ，但这样我就无法获得特定线程数的时间。
这个分配可能是完全错误的吗？

Answer 1

您同时只运行5个任务，那么为什么要为100000分配空间？仅为正在运行的任务分配矩阵就足够了。

此外，没有理由将矩阵注入MatrixMoltiplication，因为您不会对这些矩阵做任何事情而只是分配它们。所以你可以改变这个

new MatrixMoltiplication(a, b)

到此：

new MatrixMoltiplication()

并仅在Executor计划时分配矩阵：

@Override
    public void run() {
        a = new int[MATRIX_SIZE][MATRIX_SIZE];
        b = new int[MATRIX_SIZE][MATRIX_SIZE];

        // rest of the runnable

与您的问题无关的其他说明：

不是使用[0-9]区间中的元素制作两个随机矩阵（然后乘以它们），而是可以一步完成：

for (int i = 0; i < S6Esercizio1.MATRIX_SIZE; i++)
     for (int j = 0; j < S6Esercizio1.MATRIX_SIZE; j++) {
          m0[i][j] = rand.nextInt(10) * rand.nextInt(10);
     }

它具有与两个[0-9]随机矩阵的乘积相同的属性。

另外，值得注意的是你不能使用rand.nextInt（82），因为与rand.nextInt（10）* rand.nextInt（10）相比它会有不同的分布。

Answer 2

您所面临的错误 - “java.lang.OutOfMemoryError：超出GC开销限制” - 意味着GC一直在尝试释放内存，但几乎无法完成任何工作。默认情况下，当JVM在GC中花费超过98％的总时间并且GC少于2％的堆恢复后，就会发生这种情况。

这意味着您的应用程序几乎耗尽了所有可用内存，并且GC一再无法清除它。

请注意，只有在几个GC周期后释放了2％的内存时，才会抛出“超出GC开销限制”错误。这意味着GC能够清洁的很少，将会再次快速填充，从而迫使GC再次重新启动清洁过程。

这形成了一个恶性循环，其中CPU 100％忙于GC并且无法进行实际工作。应用程序的最终用户面临着极端的减速 - 过去以毫秒为单位完成的操作现在可能需要几分钟才能完成。因此，“java.lang.OutOfMemoryError：GC开销超出限制”消息是一个非常好的示例，表明了一个失败的快速原则。

快速解决此问题的方法是增加堆大小 - 添加（或增加（如果存在）-Xmx参数，指定应用程序有资格使用多少堆。

Java任务 - 内存不足

2 个答案: