Java可能比C++快嗎？為什么？

這是一段用C++寫的計算十萬以內(nèi)的回文素數(shù)算法。

#include <iostream>
using namespace std;
int main()
{
    int input_num=100000;
    int pp_count=0;
    for(int each=2; each<=input_num; each++)
    {
        int factorization_lst=0;
        for(int factor=1; factor<=each; factor++)
            if(each%factor==0&&!(factor>each/factor))
                factorization_lst++;
        if(factorization_lst==1)
        {
            int antitone=0,each_cpy=each;
            while(each_cpy)
            {
                antitone=antitone*10+each_cpy%10;
                each_cpy/=10;
            }
            if(antitone==each)
            {
                pp_count++;
                cout<<pp_count<<':'<<each<<endl;
            }
        }
    }
    return 0;
}

稍微做一下修改的Java版，加了計時相關的部分。

public class main {
    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        int input_num = 100000;
        int pp_count = 0;
        for (int each = 2; each <= input_num; each++) {
            int factorization_lst = 0;
            for (int factor = 1; factor <= each; factor++)
                if (each % factor == 0 && !(factor > each / factor))
                    factorization_lst++;
            if (factorization_lst == 1) {
                int antitone = 0, each_cpy = each;
                while (each_cpy != 0) {
                    antitone = antitone * 10 + each_cpy % 10;
                    each_cpy /= 10;
                }
                if (antitone == each) {
                    pp_count++;
                    System.out.println(pp_count + ":" + each);
                }
            }
        }
        System.out.println(System.currentTimeMillis() - start);
    }
}

執(zhí)行結果：


同樣的算法，C++用了230s，Java只用了124s。這是為什么呢，不是說C++的速度更快嗎？

注：運行環(huán)境是樹莓派3B的官方raspbian(在我的筆記本上運行過，但僅相差一秒不明顯，java17s)，C++和Java分別用的默認倉庫的codeblocks和eclipse(都不是最新版本，eclipse的版本是2012年的3.8.1，codeblocks是2016年的16.01)，gcc已經(jīng)默認開啟了-O2優(yōu)化選項，但還是如此相差懸殊。已經(jīng)看過類似于這樣的解釋文章。但還是不太明白。我的代碼只有一個main，沒有內(nèi)聯(lián)函數(shù)。Java編譯器難道不也是只分指令集的嗎，怎么能夠編譯出更加優(yōu)化的字節(jié)碼呢？而且這段代碼，Java還能怎么優(yōu)化呢？

追加：
按照@Untitled(sf沒有艾特的功能嗎)的提示，做下一個實驗證明JIT對Java執(zhí)行速度的影響。這次使用命令行直接編譯，繞過IDE的影響。個人感覺兩分鐘僅輸出百來行的話IO操作對速度的影響可忽略不計。
(由于這次圖片屢次上傳失敗因此只貼出shell相關操作，加上C++編譯結果)

pi@raspberrypi:~/workspace/testjava/src $ javac main.java
pi@raspberrypi:~/workspace/testjava/src $ java main
1:2
# 省略計算輸出
113:98689
110494
# 110秒，比在eclipse中執(zhí)行的速度還快，接下來禁用JIT
pi@raspberrypi:~/workspace/testjava/src $ java -Xint main
1:2
# 省略計算輸出
113:98689
797514
# 797秒，明顯慢于使用JIT的
pi@raspberrypi:~/workspace/testjava/src $ 
# C++編譯
pi@raspberrypi:~/cpplearn $ g++ -o main main.cpp
pi@raspberrypi:~/cpplearn $ time ./main
1:2
# 省略計算輸出
113:98689

real    4m5.606s
user    4m5.581s
sys    0m0.000s
#245秒，接下來啟用-O2選項
pi@raspberrypi:~/cpplearn $ g++ -O2 -o main main.cpp
pi@raspberrypi:~/cpplearn $ time ./main
1:2
# 省略計算輸出
113:98689

real    3m50.631s
user    3m50.384s
sys    0m0.010s
# 230秒，快了一點，和在codeblocks編譯的速度差不多
pi@raspberrypi:~/cpplearn $ 

JIT確實是大幅度提升了Java的執(zhí)行速度。(從797到110)

看了一下JIT的相關資料(1,2)，感覺就算是這樣，也不過就是不經(jīng)過JVM直接執(zhí)行了Java代碼，這和C++的編譯原理不是一樣的嗎？最多只是持平，怎么還會快這么多呢？
其實我不懂怎么反匯編，所以也不知道這怎么回事。我的循環(huán)也不是空的?？赡艿脑挘蚁胫繨ava的JIT是怎么加快執(zhí)行這段代碼的速度的。

追加：
經(jīng)過幾次實驗，發(fā)現(xiàn)在x86/x64架構中無論是在Windows還是Linux，實體機還是虛擬機，C++的速度在總體上都比Java更勝一籌。arm的設備我除了樹莓派，剩下的只有Android手機了。我準備在一臺諾基亞7(驍龍630，4GB，原生Android 8.0，無root，已經(jīng)盡可能關掉所有后臺應用，在我看來是相當穩(wěn)定的測試環(huán)境。)上面進行測試。用來測試的軟件有兩個在手機上運行的IDE(部署Linux Deploy還是太麻煩了)：AIDE (用來編譯Java代碼)和CIDE (用來編譯C++代碼，編譯器為aarch64的gcc7.2)。

由于在CIDE無法顯示程序執(zhí)行時間，因此這次在C++代碼也加入了計時。

#include <iostream>
#include <ctime>
using namespace std;
int main()
{
    clock_t start = clock();
    int input_num = 100000;
    int pp_count = 0;
    for (int each = 2; each <= input_num; each++)
    {
        int factorization_lst = 0;
        for (int factor = 1; factor <= each; factor++)
            if (each % factor == 0 && !(factor > each / factor))
                factorization_lst++;
        if (factorization_lst == 1)
        {
            int antitone = 0, each_cpy = each;
            while (each_cpy)
            {
                antitone = antitone * 10 + each_cpy % 10;
                each_cpy /= 10;
            }
            if (antitone == each)
            {
                pp_count++;
                cout << pp_count << ':' << each << endl;
            }
        }
    }
    cout << 1000*(clock() - start) / CLOCKS_PER_SEC;
    return 0;
}

優(yōu)化選項改成使用-O3(默認為-Os)

執(zhí)行結果：(這已經(jīng)是我挑選出來所用時間最短的了)

C++用了43s

Java用了37s

.....
(已經(jīng)經(jīng)過多次測試)

追加：
聽從Untitled的建議使用clang編譯(Raspbian默認沒有安裝，還得自己apt install clang一下)
速度有了質(zhì)的飛躍。(但還沒越過Java)
不使用優(yōu)化選項：3m22s(202s)
使用-O2選項：3m05s(185s)(使用-O3與-O2的執(zhí)行速度是差不多的)

順帶一提，我再次執(zhí)行java版時去掉計時的那兩行代碼，

    //long start = System.currentTimeMillis();
    //System.out.println(System.currentTimeMillis() - start);

然后使用time命令計時，結果時間延長了零點幾秒...

追加：
今晚身體不適，但還是抽出一點時間寫了Android上的測試應用。(源，下載)
在編寫過程中，我已經(jīng)盡量保證了公平。
因為今晚急著早點休息，暫時未進行充分的測試(但大體上C++比Java快很多)。大家可以自行下載測試一下，晚些時候我再發(fā)布一下詳細測試結果。

主要代碼：

MainActivity.java

package ryuunoakaihitomi.javacppperfcomparison;

import android.annotation.SuppressLint;
import android.app.Activity;
import android.os.Bundle;
import android.util.Log;
import android.view.WindowManager;
import android.widget.Toast;

import java.util.Timer;
import java.util.TimerTask;

public class MainActivity extends Activity {

    public static final String TAG = "JCPC";

    static {
        System.loadLibrary("native-lib");
    }

    @SuppressWarnings("ConstantConditions")
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
        setContentView(R.layout.activity_main);
        getActionBar().setTitle("logcat -s JCPC");
        Log.i(TAG, "Finding palindromic primes within 100,000.(Waiting for 3s)");
        new Timer().schedule(new TimerTask() {
            @Override
            public void run() {
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        final long jTime = pcTimer(true);
                        final long cTime = pcTimer(false);
                        runOnUiThread(new Runnable() {
                            @SuppressLint("DefaultLocale")
                            @Override
                            public void run() {
                                Toast.makeText(getApplicationContext(), String.format("java:%d\ncpp:%d", jTime, cTime), Toast.LENGTH_LONG).show();
                                finish();
                            }
                        });
                    }
                }).start();
            }
        }, 3000);
    }

    public native void cpp();

    long pcTimer(boolean isJava) {
        long lStart = System.currentTimeMillis();
        if (isJava)
            Java.kernel();
        else
            cpp();
        long lTime = System.currentTimeMillis() - lStart;
        Log.i(TAG, "total time:" + lTime);
        return lTime;
    }
}

Java.java

package ryuunoakaihitomi.javacppperfcomparison;

public class Java {

    static {
        System.loadLibrary("native-lib");
    }

    static void kernel() {
        int iInputNumber = 100000;
        int iPalprimeCount = 0;
        for (int iEach = 2; iEach <= iInputNumber; iEach++) {
            int iFactorizationList = 0;
            for (int iFactor = 1; iFactor <= iEach; iFactor++)
                if (iEach % iFactor == 0 && !(iFactor > iEach / iFactor))
                    iFactorizationList++;
            if (iFactorizationList == 1) {
                int iAntitone = 0, iEachCopy = iEach;
                while (iEachCopy != 0) {
                    iAntitone = iAntitone * 10 + iEachCopy % 10;
                    iEachCopy /= 10;
                }
                if (iAntitone == iEach) {
                    iPalprimeCount++;
                    ResultPrint(iPalprimeCount, iEach);
                }
            }
        }
    }

    public static native void ResultPrint(int c, int e);
}

native-lib.cpp

#include <jni.h>
#include <android/log.h>
#include <string>

using namespace std;

void kernel();

void kernel_log(string, int, int);

extern "C" JNIEXPORT void

JNICALL
Java_ryuunoakaihitomi_javacppperfcomparison_MainActivity_cpp(
        JNIEnv *,
        jobject /* this */) {
    kernel();
}

void kernel() {
    int input_num = 100000;
    int pp_count = 0;
    for (int each = 2; each <= input_num; each++) {
        int factorization_lst = 0;
        for (int factor = 1; factor <= each; factor++)
            /*Expression can be simplified to 'factor <= each / factor' less... (Ctrl+F1)
            This inspection finds the part of the code that can be simplified, e.g. constant conditions, identical if branches, pointless boolean expressions, etc.*/
            if (each % factor == 0 && factor <= each / factor)
                factorization_lst++;
        if (factorization_lst == 1) {
            int antitone = 0, each_cpy = each;
            while (each_cpy) {
                antitone = antitone * 10 + each_cpy % 10;
                each_cpy /= 10;
            }
            if (antitone == each) {
                pp_count++;
                kernel_log("c", pp_count, each);
            }
        }
    }
}

void kernel_log(string t, int c, int e) {
    __android_log_print(ANDROID_LOG_DEBUG, "JCPC", "%s %d:%d", t.c_str(), c, e);
}

extern "C"
JNIEXPORT void JNICALL
Java_ryuunoakaihitomi_javacppperfcomparison_Java_ResultPrint(JNIEnv *, jobject, jint c,
                                                             jint e) {
    kernel_log("j", c, e);
}

追加：

準備環(huán)境：

• 測試之前已經(jīng)完全運行過一次
• 禁用Xposed，暫時凍結了占用后臺的應用，電量至少在30%保證穩(wěn)定供電

實驗三次取各自的最小值，實驗結果：
說明：表格前四列的值均來自于android.os.Build中對應名稱的常量

可以看出，絕大多數(shù)的arm Android設備運行C++的速度快過Java。但是最后這一行的結果超出了預料。

這個設備的CPU是驍龍600。（好奇怪......）

另：我前兩天買了一個香橙派zero plus，用的全志H5。C++45s，java70s。

我的所有arm設備已經(jīng)測試完成，我能不能得到以下結論。

在一小部分的arm指令集架構設備中，Java的運行速度會快于C++。

想知道原因。