En gardant une référence mondiale pour la JNIEnv environnement

Je suis le stockage hors JNIEnv mondial pour que je puisse appeler statique méthodes de java plus tard. Mais est-il nessasary pour stocker hors d'un pointeur global de la JNIEnv, ils comme on le ferait avec tout autre objet java, ou est-il un cas particulier qui ne nécessite pas de cette.

JNIEnv* globalEnvPointer;

[JNICALL etc] void init(JNIENv* env, [etc])
{
   //required?
   globalEnvPointer = (JNIENv*) (env*)->GetGlobalRef(env, env);
   //or is this OK?
   globalEnvPointer = env;
}

Modifier

Je suis bing un peu stupide ici, toutes les méthodes qui leur permettront d'utiliser globalEnvPointer, sont invoqués dans mon init parce que mon init est en fait mon c du programme main méthode, qui ne reviendra pas jusqu'à la fin du programme. Je suis également en utilisant aucun autre thread dans la partie c du programme. Je pense que cela simplifie la réponse.

JNIEnv* globalEnvPointer;

[JNICALL etc] void main(JNIENv* env, [etc])
{
   //required?
   globalEnvPointer = (JNIENv*) (env*)->GetGlobalRef(env, env);
   //or is this OK?
   globalEnvPointer = env;
   someMethod();
}

void someMethod()
{
   //use globalEnvPointer here
}
InformationsquelleAutor weston | 2012-09-14
  1. 49

    Vous ne pouvez pas mettre en cache les JNIEnv pointeur. Lire à ce sujet ici:

    La JNI pointeur d'interface (JNIEnv) n'est valide que dans le thread courant. Si un autre thread besoin d'accéder à la machine virtuelle Java, il faut d'abord appeler AttachCurrentThread() pour se fixer à la machine virtuelle et d'obtenir un pointeur d'interface JNI. Une fois fixé à la machine virtuelle, un thread natif fonctionne comme un ordinaire Java thread en cours d'exécution à l'intérieur d'une méthode native. Le natif des threads reste attaché à la machine virtuelle jusqu'à ce qu'il appelle DetachCurrentThread() à se détacher.

    Ce que vous pouvez faire est de mettre en cache les JavaVM pointeur à la place.

    static JavaVM *jvm;

[JNICALL etc] void init(JNIENv* env, [etc])
{
   jint rs = (*env)->GetJavaVM(env, &jvm);
   assert (rs == JNI_OK);
}

    Et puis quand vous en avez besoin alors JNIEnv pointeur d'un contexte où il n'est pas donné pour ce faire:

    void someCallback() {
    JNIEnv *env;
    jint rs = (*jvm)->AttachCurrentThread(jvm, &env, NULL);
    assert (rs == JNI_OK);
    //Use the env pointer...
}

    Mais à chaque fois que vous appelez une méthode native de Java env pointeur à utiliser est donnée:

    JNIEXPORT jint JNICALL Java_package_Class_method(JNIEnv *env, jobject obj) {
    //just use the env pointer as is.
}
    • C'est tout un fil, cela fait-il une différence? c'est à dire mon init est appelé dans le même thread que qui fera plus tard appeler la statique méthodes de java.
    • Toujours utiliser le JNIEnv pointeur qui est à venir dans la fonction C. Comme dans mon dernier exemple.
    • Veuillez voir mon edit, dans votre exemple, si Java_package_Class_method appelé someCallback, vous n'auriez pas besoin de passer par JavaVM feriez-vous? En effet c'est ce que je fais, juste à l'aide de l'échelle mondiale plutôt que de les passer à someCallback.
    • Vous pourriez, mais n'est pas de ce genre de laid? Le stockage temporaire des données dans des variables globales à être utilisé à partir d'autres méthodes est un anti-modèle à mes yeux.
    • Oui je suis d'accord, mais je suis en train de prendre une énorme c base de la source et de réécrire 100+ assemblée des méthodes en java (comme someCallback). Nous parlons de quelques milliers de places ont été invokations sont effectuées. En Plus de la même source de la base doivent toujours compiler pour la cible d'origine, donc en passant JNIEnv autour de est en fait le laid solution. Merci pour tous les conseils, je vais bare à l'esprit, si j'ai besoin d'utiliser des threads.
    • Je ne voudrais pas créer ma propre fonction init si il y a déjà JNI_OnLoad, qui transmet la JavaVM.
    • C'est quelque chose que vous pouvez dire à l'OP dans un commentaire, en vertu de sa question. J'ai simplement utilisé ses propres fonctions. Il peut avoir une raison que nous ne savons pas à propos de l'utilisation d'une fonction init.
    • Les OP peuvent avoir besoin d'un distinct fonction init, mais peut-être qu'il ne connaissent pas l'existence de JNI_OnLoad à tous. Il vient s'étend la réponse. Il n'est pas fait de critique, juste un peu d'extension d'indication. Je n'écris pas ma propre réponse, parce que je pense que votre réponse est déjà bon, et vous devriez obtenir le maximum de points. Cependant, pensez aussi à propos d'autres personnes de la lecture de votre réponse, et pas seulement les OP et y sont expérimentés et inexpérimentés personnes sous eux.

    InformationsquelleAutor maba