Question

我的老师让我写一个程序，它使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;
}

Answer 1

“每行代码都依赖于前一行”

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

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

必须被称为mxm次。每个这样的调用都独立于其他调用，因此所有调用都可以并行运行。

显然，为每个单独的调用创建一个线程是一个坏主意，因为开销太大。最佳方法是将整组调用拆分为一组较大的作业。最佳作业数等于计算机中的处理器数。核心和核心线程被视为独立的处理器。

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

1 个答案: