Comment faire pour démarrer un nouveau thread de JNI

Plus simple est d'utiliser le C++11 classe thread. Voir cette rubrique sur la façon d'activer le C++11 avec Android NDK. Voir aussi ce post si vous rencontrez des problèmes pour faire classe thread de travail. Ensuite, vous pouvez l'utiliser comme ceci:

#include <thread>         //std::thread

void foo() 
{
   //do stuff...
}

void bar(int x)
{
   //do stuff...
}

JNIEXPORT void JNICALL 
Java_org_testjni_android_Game_someFunction(JNIEnv * env, jobject  obj)
{
   std::thread first (foo);     //spawn new thread that calls foo()
   std::thread second (bar,0);  //spawn new thread that calls bar(0)

    //main, foo and bar now execute concurrently

    //synchronize threads:
   first.join();                //pauses until first finishes
   second.join();               //pauses until second finishes

}

Si vous ne pouvez pas utiliser le C++11, il suffit d'utiliser pthread (POSIX thread), ce qui n'est pas très différent, sauf que c'est comme de vieux C:

#include <pthread.h>

    //This function will be called from a thread

void *call_from_thread(void *) {
    //do stuff
    return NULL;
}

JNIEXPORT void JNICALL 
Java_org_testjni_android_Game_someFunction(JNIEnv * env, jobject  obj)
{
        pthread_t t;

        //Launch a thread
        pthread_create(&t, NULL, call_from_thread, NULL);

        //Join the thread with the main thread
        pthread_join(t, NULL);
 }

Voici quelques plus d'infos sur l'utilisation des threads POSIX avec Android.

Aussi, vous aurez besoin de chercher comment faire pour lier les JNIEnv pointeur vers le thread courant si vous voulez l'utiliser dans n'importe quel thread, mais celui de la JNI fonction est appelée. À partir de la JNI spec:

De la création de la VM

La JNI_CreateJavaVM() la fonction de charge et initialise une machine virtuelle Java et
retourne un pointeur vers le pointeur d'interface JNI. Le thread qui appelle
JNI_CreateJavaVM() est considéré comme le thread principal.

Attacher à la VM

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

Du joint de fil doit avoir assez d'espace de pile pour effectuer une
montant raisonnable de travail. L'allocation d'espace de pile par thread est
système d'exploitation spécifique. Par exemple, en utilisant les pthreads, la taille de la pile
peut être spécifié dans la pthread_attr_t argument à pthread_create.

Se détacher de la VM

Un thread natif attaché à la machine virtuelle doit appeler DetachCurrentThread() pour
se détacher avant de quitter. Un thread ne peut pas se détacher de lui-même si il y
sont des méthodes de Java sur la pile d'appel.

OriginalL'auteur Steve M