Java 用jacobi算法实现laplace方程

该算法遍历一个2D NxN数组，使每个元素成为其周围4个相邻元素（左、右、上、下）的平均值

NxN数组最初为全零，并由一个边距包围，边距为1，如中所示 下面是一个例子。1永远不会改变，0一点一点地增加

             1 1 1 1 1 1 1 1
             1 0 0 0 0 0 0 1
             1 0 0 0 0 0 0 1
             1 0 0 0 0 0 0 1
             1 0 0 0 0 0 0 1
             1 0 0 0 0 0 0 1
             1 0 0 0 0 0 0 1
             1 1 1 1 1 1 1 1

我已经实现了以下代码，并且正在获取数组索引越界异常。请纠正我

my code :
       public class Main {
static int NO_OF_THREADS =8;

/**
 * @param args the command line arguments
 */
public static void main(String[] args) {
    // TODO code application logic here
      Jacobi jacobi = new Jacobi(NO_OF_THREADS);
      jacobi.initialize();
      jacobi.create_threads();
    }

  }//end of Main class

  public class Jacobi {
int ROWS=1000,COLS=1000;
private int i;
private int upper=100;//prevents buffer overflow
private int lower=99;//prevents buffer overflow
private int j;
private double[][] jacobi=new double[ROWS][COLS];
private int NO_OF_THREADS;


public Jacobi(int k)
{
    NO_OF_THREADS=k;
}

public  void initialize() {
        for(i=1;i<=upper;i++)
           {
           for(j=1;j<=upper;j++)
                 {

                       if((i==1)||(i==upper)||(j==1)||(j==upper)){
                      jacobi[i][j]=1.0;
                       }

                   else
                          jacobi[i][j]=0.0;


                 }

             }

    }
              public double[][] getJacobi()
              {
                    return jacobi;
              }

              public void create_threads()
              {
                   theThread[] threads=new theThread[NO_OF_THREADS];
                   for(int k=1;k<=NO_OF_THREADS;k++)
                   {
                       threads[k]=new theThread();
                       threads[k].start();
                    }
               }
               //Inner class of Jacobi

             class theThread extends Thread {

               @Override
              public void run()
              {
                   for(int q=2;q<=lower;q++)
                   {

                     System.out.println("The ID of this thread is: "+getName());
                     for(int j=2;j<=lower;j++)
                      {
                        synchronized(Jacobi.this)
                         {

                        jacobi[q][j]=(jacobi[q-1][j]+jacobi[q+1][j]+jacobi[q] [j-1]+jacobi[q][j+1])/4;
                         }//end of synchronized
              }//end of inner for loop


          }//end of for loop
     }
}//end of theThread class
}//end of jacobi class

我的代码：
公共班机{
线程的静态int NO_=8；
/**
*@param指定命令行参数
*/
公共静态void main（字符串[]args）{
//此处的TODO代码应用程序逻辑
Jacobi-Jacobi=新的Jacobi（没有线程）；
初始化（）；
jacobi.create_threads（）；
}
}//主课结束
公共类雅可比{
int行=1000，COLS=1000；
私人互联网i；
private int upper=100；//防止缓冲区溢出
private int lower=99；//防止缓冲区溢出
私人int j；
私有双精度[][]雅各比=新双精度[行][COLS]；
线程的私有int NO_；
公共雅各比（int k）
{
_线程的数量=k；
}
公共无效初始化（）{
对于（i=1；i

int ROWS,COLS=1000;

我想你想把它改成

int ROWS=1000, COLS=1000;

否则，
行
设置不正确…
在原始代码中，
行
将被设置为
0
，而不是
1000
。是的，我已经纠正了这两个错误，即设置行=1000和进行同步（Jacobi.this）线程之间，但我仍然得到数组索引超出范围。因此，我尝试通过反复试验来修正上限和下限，但仍然不起作用。@SANJAY RAO:请发布更新的代码好吗？请修正缩进好吗，否则很难阅读：）是的，我已经编辑了同一篇文章，上面提到了更正。如果仍然不容易阅读，请让我知道。请修复缩进！每个“{”应该与相应的“}”对齐，每个“{”应该从包含“{”的位置缩进一致的数量。目前“}”表示“内部for循环结束”缩进比外部“for”循环的“{”小，这使得代码很难理解。（您的编辑器程序应该能够帮助您完成此操作…）。这不是您问的问题，而是在查看代码时，您在“this”上同步的问题，它引用了您的线程，因此没有实际效果。我猜您的目的是在线程之间进行同步，在这种情况下，您应该在“Jacobi.this”上进行同步（该线程的Jacobi的封闭实例对所有创建的线程都是通用的）。我执行了您的更正，但我仍然对输出感到困惑…我是否必须生成线程。在create_threads（）中使用sleep（300）？在启动所有线程并使用线程[k]后，再使用一个for循环。join（）仍然获得数组索引超出边界异常！！！