比较c#，c++和Java的性能(c#的奇怪行为）

我正在用C++，C#和Java实现Floyd-Warshall算法。 在每种语言中，我使用顺序和并行实现 测试后结果是：
（运行时间仅适用于主函数和读取文件，变量的Inti和...不测量。
在此处下载源代码

C++

• IDE：Netbeans
• 编译器：MinGW-4.8.1
• 顺序时间 ： 9.333000
• 并行时间 ： 2.539000
• 将OpenMp用于普拉莱尔

如果 NumOfThreads =1，则为顺序，否则为并行

变量

#define n 1000 /* Then number of nodes */
double dist[n][n];
    void floyd_warshall(int NumOfThreads) {
    int i, j, k;
         omp_set_num_threads(NumOfThreads);
    for (k = 0; k < n; ++k)
       #pragma omp parallel for private(i,j)
        for (i = 0; i < n; ++i)
            for (j = 0; j < n; ++j)
                    if ((dist[i][k] * dist[k][j] != 0) && (i != j))
                     if ((dist[i][k] + dist[k][j] < dist[i][j]) || (dist[i][j] == 0))
                        dist[i][j] = dist[i][k] + dist[k][j];    }

.java

• IDE：Netbeans
• 编译器：Netbeans 默认值
• 顺序 ： 11.632
• 并行时间 ： 3.089
• -Xms512m -Xmx1024m
• import java.util.concurrent.Callable;
  import java.util.concurrent.ExecutionException;
  import java.util.concurrent.ExecutorService;
  import java.util.concurrent.Future;

爪哇变量

 public final int numNodes =1000;
    public final double[][] costs= new double[numNodes][numNodes] ;

我没有把Java代码放在这里，因为它工作正常（我认为）

C#

1. IDE：Visual Studio 2012
2. 编译器：Visual Studio 2012 默认
3. 顺序时间 ： 31.312
4. 并行时间 ： 8.920
5. 使用System.Threading.Tasks;

变量

  const int n = 1000;
    static double[,] dist = new double[n, n];

并行代码

   static  void floyd_warshall(ParallelOptions pOp)
    {
        int k;     
        for (k = 0; k < n; ++k)
            Parallel.For<int>(0, n, pOp, () => 0, (i, loop, j) =>
                {
              for (j = 0; j < n; ++j)
               if ((dist[i, k] * dist[k, j] != 0) && (i != j))
                  if ((dist[i, k] + dist[k, j] < dist[i, j]) || (dist[i, j] == 0))
                            dist[i, j] = dist[i, k] + dist[k, j];
                    return 0;
                }, (j) => { });

单一代码

 static void floyd_warshallSingle()
  {
      int i, j, k;
      for (k = 0; k < n; ++k)
          for (i = 0; i < n; ++i)
              for (j = 0; j < n; ++j)
                  if ((dist[i,k] * dist[k,j] != 0) && (i != j))
                      if ((dist[i,k] + dist[k,j] < dist[i,j]) || (dist[i,j] == 0))
                          dist[i,j] = dist[i,k] + dist[k,j];
  }

我的 C# 实现有什么问题？
都使用相同的文件
现在我的问题是为什么用 C# 解决这个算法需要更多时间？Java 和 C++ 的运行时间几乎相同，但我认为我使用 C# 的实现是错误的，因为 C# 和 C++ 之间的这种差异很奇怪！
请帮助我改进我的 C# 实现或说出一些原因谢谢！

编辑 1

我将数组更改为交错数组，结果更改为：

• 顺序 ： 19.22
• 并行时间 ： 4.903

C#和C ++或Java之间仍然有很大的不同！知道为什么吗？
新变量

const int n = 1000;
    static double[][] dist = new double[n][];

新代码 ：

static void floyd_warshallSingle()
  {
      int i, j, k;
      for (k = 0; k < n; ++k)
          for (i = 0; i < n; ++i)
              for (j = 0; j < n; ++j)
                  if ((dist[i][k] * dist[k][j] != 0) && (i != j))
                      if ((dist[i][k] + dist[k][j] < dist[i][j]) || (dist[i][j] == 0))
                          dist[i][j] = dist[i][k] + dist[k][j];
  }

   static  void floyd_warshall(ParallelOptions pOp)
    {
        int k;     
        for (k = 0; k < n; ++k)
            Parallel.For<int>(0, n, pOp, () => 0, (i, loop, j) =>
                {
                    for (j = 0; j < n; ++j)
                        if ((dist[i][k] * dist[k][j] != 0) && (i != j))
                            if ((dist[i][ k] + dist[k][j] < dist[i][ j]) || (dist[i][j] == 0))
                                dist[i][ j] = dist[i][k] + dist[k][j];
                    return 0;
                }, (j) => { });
    }