Java 这里的并行概念在哪里？

我的老师让我写一个程序，用线程将2D矩阵相乘，但我在这里找不到使用线程的好处！如何在两个线程之间分配工作？谁能向我解释一下这样做的好处是什么，谢谢

这是我没有线程的代码 事实上，每件事都是相互依存的，所以我想不出分工合作的办法

 public static void main(String[] args)
{

    Scanner in=new Scanner(System.in);
    out.println("Enter your first array rows");
    int r1=in.nextInt();
    out.println("Enter your first array cloumns");
    int c1=in.nextInt();

    double[][] m1=new double[r1][c1];

    out.println("Enter your second array rows");
    int r2=in.nextInt();
    out.println("Enter your second array cloumns");
    int c2=in.nextInt();

    double[][] m2=new double[r2][c2];

    if(c1 == r2)
    {
        out.println("Enter your first matrix numbers");
        for(int i=0;i<m1.length;i++)
        {
            for(int j=0;j<m1[0].length;j++)
            {
                m1[i][j]=in.nextDouble();
            }
        }

        out.println("Enter your second matrix numbers");
        for(int i=0;i<m2.length;i++)
        {
            for(int j=0;j<m2[0].length;j++)
            {
                m2[i][j]=in.nextDouble();
            }
        }

        double[][] product=multiply(m1,m2);
        for(int i=0; i<product.length;i++)
        {
            for(int j=0;j<product[0].length;j++)
            {
                out.print(product[i][j] + " ");
            }
            out.println();
        }
    }
     else
    {
            out.println("Sorry you can't multiply these metrecies");
    }
 }

//A method for normal multiplication without threads

public static double[][] multiply(double[][] a,double[][] b)
{
    int aRows=a.length;
    int aColumns=a[0].length;
    int bColumns=b[0].length;

    double[][] c=new double[aRows][bColumns];
    for(int i=0;i<aRows;i++)
    {
        for(int j=0;j<bColumns;j++)
        {
            for(int k=0;k<aColumns;k++)
            {
                c[i][j]=c[i][j] +  a[i][k] * b[k][j];
            }

        }
    }

    return c;
}

publicstaticvoidmain（字符串[]args）
{
扫描仪输入=新扫描仪（系统输入）；
println（“输入第一个数组行”）；
int r1=in.nextInt（）；
println（“输入第一个数组克隆”）；
int c1=in.nextInt（）；
双精度[][]m1=新双精度[r1][c1]；
println（“输入第二个数组行”）；
int r2=in.nextInt（）；
println（“输入第二个数组克隆”）；
int c2=in.nextInt（）；
双精度[]m2=新双精度[r2][c2]；
如果（c1==r2）
{
out.println（“输入您的第一个矩阵编号”）；
对于（int i=0；i“每行代码取决于前一行”

你不应该从代码开始，代码应该是结果。从函数依赖关系开始，函数的结果取决于其参数。找到要使用的函数。将计算表示为函数调用树。然后，该树的并行分支是并行执行的候选分支

矩阵乘法可以描述为调用著名函数

每次调用都独立于其他调用，因此所有调用都可以并行运行

显然，为每个单独的调用创建一个线程是个坏主意，因为开销太大。最佳方法是将整个调用集拆分为一组较大的作业。作业的最佳数量等于计算机中的处理器数量。内核和核心线程被视为单独的处理器。
按“2D度量”你是说“二维矩阵”吗？提示：问问你自己不同操作之间有什么依赖关系。如果你有两个100x100矩阵相乘，并且你有一小群人，你会如何分配工作？写出矩阵相乘的逻辑，也许多个线程如何帮助“2D矩阵”会变得更清楚，实际上我只有2个矩阵，所以每行代码都依赖于前一行，我找不到一种方法将工作划分为两个线程！你指的是什么代码？你没有显示任何尝试。@AndrewS我用代码更新了我的问题，提前谢谢你！