Java字符串对象创建:Java和Java的执行时间差在JNI中 [英] Java String Object creation : Execution time difference in both Java & in JNI

问题描述

我通过创建一个字符串对象(新的String("some string");)进行了1亿次的java和jni之间的时差测试.通过Java代码进行测试时，大约需要1秒钟才能执行.但是，通过Jni代码对其进行测试时，大约需要31秒.

I did a time difference test between java and jni, by creating a string object (new String("some string");) for 100 million times. When testing this via Java code it took around 1 second to execute. But when testing it via Jni code it took around 31 seconds.

对于JNI部分，我是否需要更改jni代码设计或需要添加其他编译器选项以提高执行速度?

For the JNI part, do I need to change the jni code design or need to add additional compiler options to increase the execution speed?

环境:
Mingw(32)
Windows 8.1(64)
Java 1.8(32)
C ++编译器选项:-shared -m32 -Wl，-add-stdcall-alias

Environment:
Mingw (32)
Windows 8.1 (64)
Java 1.8 (32)
C++ Compiler option : -shared -m32 -Wl,--add-stdcall-alias

(下面给出的每个文件中需要的代码部分)

C ++文件:

class javaString {
    jclass cls;
    jmethodID method;
    jstring strNew;
    jobject obj;
public:
    javaString() {
    }
    void myInit(JNIEnv *env) {
        jclass cls1 = env-> FindClass("java/lang/String");
       cls = (jclass) env->NewGlobalRef(cls1);
       env->DeleteLocalRef(cls1);
       method = env->GetMethodID(cls, "<init>", "(Ljava/lang/String;)V");
    }

void myCall(JNIEnv *env, long lng) {
    strNew = env->NewStringUTF("Apple");
    for (long i = 0; i < lng; i++) {
        obj = env->NewObject(cls, method, strNew);
        env->DeleteLocalRef(obj);
    }
    env->DeleteLocalRef(strNew);
    env->DeleteGlobalRef(cls);
}
};

javaString objStr;

JNIEXPORT void JNICALL Java_c_wrapperforjavaclass_clsNative_fnInit
(JNIEnv *env, jobject obj) {
    objStr.myInit(env);
}

JNIEXPORT void JNICALL Java_c_wrapperforjavaclass_clsNative_fnCall
(JNIEnv *env, jobject obj, jint a) {
     long lng = a;
     objStr.myCall(env, lng);
}

Java文件:

public class clsNative {
    public native void fnInit();
    public native void fnCall(int a);
    public void fnProcess2(int a){
        for(int i=0;i<a;i++){
            String str = new String("Apple");
            str=null;
        }
    }
}

Java文件(测试):

clsNative a = new clsNative();
        boolean blnJNITest=true;
        String s1, s2;

        s1 = Calendar.getInstance().getTime().toLocaleString();
        int ii = 100000000; //100 million
        if (blnJNITest) {
            a.fnInit();
            a.fnCall(ii);
        } else {
            a.fnProcess2(ii);
        }
        s2 = Calendar.getInstance().getTime().toLocaleString();
        System.out.println(s1);
        System.out.println(s2);

在字符串对象(java/lang/String)的地方，我也尝试了以下方法

In the place of string object (java/lang/String), i have tried the below too

1. StringBuilder strObj =新的StringBuilder(int容量= 100);
2. Integer intObj =新Integer(int值= 100);

在所有情况下，这大约都是同一时间.

In all the cases it is taking around same time.

推荐答案

但是在纯Java中，优化编译器可以理解"创建的字符串以立即将其销毁，并且合法地不执行任何操作.当涉及到JNI时，Java和C都不会避免执行每个步骤.

But in pure Java, the optimizing compiler can "understand" that string is created to be destroyed immediately, and legitimately do nothing. When JNI is involved, neither Java nor C may avoid performing every step.

这篇关于Java字符串对象创建:Java和Java的执行时间差在JNI中的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！