使用多线程在java中生成一个矩阵，以利用超级计算机的所有CPU核

我正在研究一个处理大量数据和计算的问题，也就是说，我们有一台处理能力为270 T触发器的超级计算机，所以我们的数据基本上是矩阵形式的，所以我们决定使用线程将矩阵的生成分为几个部分，所以问题只是我们如何实现在我们的函数中，我们只是使用参数来划分任务，但线程的run函数并没有使用参数

static int start=0,end;
int row=10000;
int col =10000,count=0,m=2203,n=401;
double p=Math.PI,t=Math.sqrt(3),pi=(p/(col+1));
double mul,a,b,c,d,e,f,xx,yy;
int[][] matrix = new int [row][col];


private void sin1()
{
    // TODO Auto-generated method 
    for (int i =start; i < row; i++)
    {
        for (int j = 0; j <col; j++) 
        {
            xx=((i+1)*pi);
            yy=((j+1)*pi);
            a=Math.cos(((2*m)-n)*((2*(xx))/3));
            b=Math.sin(((2*(n*(yy)))/t));
            c=Math.cos(((((2*n)-m)*(2*(xx)))/3));
            d=Math.sin(((2*m)*(yy)/t));
            e=Math.cos((((m+n)*(2*(xx)))/3));
            f=Math.sin((((m-n)*(2*(yy)))/t));

               mul=(a*b)-(c*d)+(e*f);

            if(mul<0)
            {
                matrix[i][j]=0;
            }
            else
            {
                matrix[i][j]=1;
            }
        System.out.print(matrix[i][j]);
        }
        System.out.println();
    }

} 

static int start=0，end；
int row=10000；
int col=10000，count=0，m=2203，n=401；
double p=Math.PI，t=Math.sqrt（3），PI=（p/（col+1））；
双mul，a，b，c，d，e，f，xx，yy；
int[][]矩阵=新的int[行][col]；
私有无效sin1（）
{
//TODO自动生成方法
for（int i=start；i对于（int j=0；j代码向我清楚地表明，您缺乏任何形式的Java编程知识。如果您想为超级计算机编写代码，这是一件坏事。幸运的是，Java有一套很好的工具来解决各种问题，但您需要知道在何种情况下使用哪些工具

在您的情况下，您可以（即）使用并行流将发电分散到各个核心，如下所示：

static final int start = 0;
static int end;
static final int row = 10000;
static final int col = 10000, count = 0, m = 2203, n = 401;
static final double t = Math.sqrt(3);
static final double pi = (Math.PI / (col + 1));

final int[][] matrix = new int[row][col];

public int generateMatrixEntry(final int i, final int j) {
  final double xx = ((i + 1) * pi);
  final double yy = ((j + 1) * pi);
  final double a = Math.cos(((2 * m) - n) * ((2 * (xx)) / 3));
  final double b = Math.sin(((2 * (n * (yy))) / t));
  final double c = Math.cos(((((2 * n) - m) * (2 * (xx))) / 3));
  final double d = Math.sin(((2 * m) * (yy) / t));
  final double e = Math.cos((((m + n) * (2 * (xx))) / 3));
  final double f = Math.sin((((m - n) * (2 * (yy))) / t));

  final double mul = (a * b) - (c * d) + (e * f);
  return (mul < 0) ? 0 : 1;
}

private void sin1() {
  IntStream.range(start, row).parallel().forEach((i) -> {
    for (int j = 0; j < col; j++) {
      matrix[i][j] = generateMatrixEntry(i, j);
    }
  });
}

static final int start=0；
静态输入端；
静态最终整数行=10000；
静态最终整数列=10000，计数=0，m=2203，n=401；
静态最终双t=数学sqrt（3）；
静态最终双pi=（Math.pi/（col+1））；
最终整数[]矩阵=新整数[行][列]；
公共整数生成器矩阵中心（最终整数i、最终整数j）{
最终双xx=（（i+1）*pi）；
最终双yy=（（j+1）*pi）；
最终双a=数学cos（（2*m）-n）*（（2*xx））/3）；
最终双b=数学sin（（（2*（n*（yy）））/t））；
最后的双c=Math.cos（（（2*n）-m）*（2*（xx））/3）；
最终双d=数学sin（（2*m）*（yy）/t）；
最后的双精度e=数学cos（（（m+n）*（2*（xx））/3））；
最终双f=数学sin（（（m-n）*（2*（yy）））/t）；
最终双mul=（a*b）-（c*d）+（e*f）；
返回（mul<0）？0:1；
}
私有无效sin1（）{
IntStream.range（start，row）.parallel（）.forEach（（i）->{
对于（int j=0；j

然而，这只是一个可能的解决方案，可能适合也可能不适合您的硬件。如果上述方法不能解决您的问题，您绝对需要有更深入的Java知识的人从集合中为您选择正确的工具。
这很难。找一个好的库。@Thorbjørnravandersen您能提出一些建议吗better@Thorbjørnravandersen上面的函数只是为了测试之后的另一个程序，它变得越来越复杂。没有。但是在你目前的技能水平下，多线程编程可能太复杂，无法获得任何优势，因为有很多开销。感谢你的帮助，还有一个问题是超级计算机不支持多线程，因为它是一个它把它看作是一个程序，所以只有一个内核被分配给我，基本上我们只是为了物理分析而这样做，所以有任何方式，那个PC的作业调度器把它当作不同的进程，我们的任务完成了上面的代码，特别是代码>并行（）。

，将使用进程允许使用的尽可能多的内核。如果在您的特殊设置中，您需要使用不同的机制-您提到的那些作业-那么您需要这些作业的API和使用该API的特定程序。如果是这种情况，那么这里没有人可以帮助您，因为没有人知道您的系统的内部如何我想详细研究这个函数。你能提供一些链接或文档吗？你应该从这里开始理解流的概念：并行流就是并行运行的流。