C，Java和Python三门编程语言性能比较

在编程中有许多语言，而不同的编程语言有时候也能实现相同的功能，那么不同语言之间的运行速度有多少差别呢？这里选择 C , Java 和 python 三门热门语言来做比较。

实验

这里使用三种语言进行矩阵乘法。 矩阵的大小为2048 x 2048（即每个矩阵的乘法和加法运算为8,589,934,592），我为它们填充了0.0到1.0之间的随机值（使用随机值而不是对所有三种语言使用完全相同的矩阵的影响可以忽略不计）。每个实验运行了五次，并计算了平均运行时间。

1.C代码

 #include <stdlib.h> 
 #include <stdio.h> 
 #include <time.h> 
   
 #define n 2048 
  
 double A[n][n]; 
 double B[n][n]; 
 double C[n][n];
  
 int main() {
  
      //populate the matrices with random values between 0.0 and 1.0
      for (int i = 0; i < n; i++) {
          for (int j = 0; j < n; j++) {
  
              A[i][j] = (double) rand() / (double) RAND_MAX;
              B[i][j] = (double) rand() / (double) RAND_MAX;
              C[i][j] = 0;
          }
      }
  
      struct timespec start, end;
      double time_spent;
 
      //matrix multiplication
      clock_gettime(CLOCK_REALTIME, &start);
      for (int i = 0; i < n; i++) {
          for (int j = 0; j < n; j++) {
              for (int k = 0; k < n; k++) {
                  C[i][j] += A[i][k] * B[k][j];
             }
         }
     }
     clock_gettime(CLOCK_REALTIME, &end);
     time_spent = (end.tv_sec - start.tv_sec) + (end.tv_nsec - start.tv_nsec) / 1000000000.0;
     printf("Elapsed time in seconds: %f \n", time_spent);
    return 0;
 }

2.Java代码

 import java.util.Random; 
  
 public class MatrixMultiplication { 
     static int n = 2048; 
     static double[][] A = new double[n][n]; 
     static double[][] B = new double[n][n]; 
     static double[][] C = new double[n][n]; 
  
     public static void main(String[] args) {
          //populate the matrices with random values between 0.0 and 1.0
          Random r = new Random();
          for (int i = 0; i < n; i++) {
              for (int j = 0; j < n; j++) {
                  A[i][j] = r.nextDouble();
                  B[i][j] = r.nextDouble();
                  C[i][j] = 0;
              }
          }
  
          long start = System.nanoTime();
          //matrix multiplication
          for (int i = 0; i < n; i++) {
              for (int j = 0; j < n; j++) {
                  for (int k = 0; k < n; k++) {
                      C[i][j] += A[i][k] * B[k][j];
                  }
              }
          }
  
          long stop = System.nanoTime();
          double timeDiff = (stop - start) * 1e-9;
          System.out.println("Elapsed time in seconds: " + timeDiff);
      }
  }

3.python代码

 import random 
 import time 
  
 n = 2048 
  
 #populate the matrices with random values between 0.0 and 1.0 
 A = [[random.random() for row in range(n)] for col in range(n)] 
 B = [[random.random() for row in range(n)] for col in range(n)] 
 C = [[0 for row in range(n)] for col in range(n)]
  
  start = time.time()
  #matrix multiplication
  for i in range(n):
      for j in range(n):
          for k in range(n):
              C[i][j] += A[i][k] * B[k][j]
  
  end = time.time()
  print("Elapsed time in seconds %0.6f" % (end-start))

如何编译与运行

#C
gcc MatrixMultiplication.c -o matrix
./matrix

#Java
javac MatrixMultiplication.java
java MatrixMultiplication

#Python
python MatrixMultiplication.py

运行时间

根据这些结果， C 比Java慢2.34倍，python 比Java慢33.34倍。

等待！！！ C 不是应该最快的吗？？？

实际上，这是不公平的比较。 当我们编译Java程序时，即使没有任何优化标志，Java JIT（即时）编译器也会自动执行优化。 但是，对于GCC（编译C程序），情况并非如此，我们必须显式设置优化标志。

因此，在编译C程序时使用了-O2和-O3优化标志，并再次进行了实验。

gcc -O2 MatrixMultiplication.c -o matrix./matrixgcc -O3 MatrixMultiplication.c -o matrix./matrix

新的运行时间

现在，Java代码比C[-O3]慢1.69倍，而Python代码慢56倍。 我做出了正确的决定（或者很幸运：-）），选择了C而不是其他编程语言。

总结结果

讨论结果

• Python相对非常慢，因为C是经过编译的，而Python是被解释的。 编译器一次将C代码转换为机器代码。 另一方面，解释器必须读取，解释和执行每一行代码，并更新机器状态（这会增加很多开销）。 将程序编译为机器代码时，CPU可以直接执行它。 但是，当涉及到解释器时，CPU将运行解释器，并且解释器本身将执行程序。 （如果您对编译器和解释器感兴趣，请阅读Vaidehi Joshi撰写的精彩文章）

• 这就是使Python非常灵活的原因。 Python牺牲了一点性能来提供更多的灵活性/高级编程功能（如果不使用C语言指定数据类型，则不能将变量初始化为n = 100，但是可以在Python中进行初始化）。

• JIT（Java编译器）位于C和Python之间。 首次执行代码时，将对其进行解释。 但是，当一段代码频繁执行时，它会实时编译为机器代码，并且进一步的执行将使用编译后的版本。

以上就是关于三门编程语言的比较结论。