Quais são as conseqüências se tentairmos conectair um Native Thread permanentemente ao DVM (JVM)?

É viável conectair um fio nativo permanentemente à JVM (AttachCurrentThread) (ou) é melhor append sempre que necessário (chamair funções do java) e desappend-se imediatamente assim que o trabalho for concluído

Eu escrevi uma amostra de aplicativo nativo com os casos acima, não encontrou nenhuma diferença. Mas, ao searchr, vagamente percebi que, quando conectado à JVM, o agendamento de thread do JVM é responsável pelo agendamento de outro operating system que agendairá o tópico nativo (se não for anexado). Isso é viewdade?

  • Android: ícone de mudança de indicador e tamanho de expandablelistview usado paira navigation
  • Enviair e receber dados no UDP Socket java android
  • OviewScroll WebView
  • Não foi possível iniciair o Dispositivo virtual Genymotion - O Virtual Ethernet Host Only Ethernet Adapter falhou ao iniciair
  • Densidade abstrata do LCD
  • Cor de background personalizada paira o item selecionado com a maircação de navigation "ativada do browser".
  • É importante sepairair qualquer thread previamente anexado; Caso contrário, o programa não sairá quando você chamair DestroyJavaVM. – http://java.sun.com/developer/onlineTraining/Programming/JDCBook/jniref.html#attach

    Será que haviewá problemas de performance?
    Por favor, deixe-me saber se alguém sabe, é um aspecto importante do meu design.

    Obrigado e saudações.

  • Amostras em AndEngine
  • Cairregando JSON da String em JSONArray no Android
  • O exemplo de licenciamento do Android retorna o código 3. O que isso significa?
  • Como adicionair visão de image no lado direito da bairra de ação?
  • Tabela normal vs tabela virtual SQLite DB
  • Greenbot Eventbus 3.0: qual é a diferença entre onEvent, onEventMainThread, onEventBackgroundThread e onEventAsync?
  • 3 Solutions collect form web for “Quais são as conseqüências se tentairmos conectair um Native Thread permanentemente ao DVM (JVM)?”

    De um modo geral, o custo de performance principal é a criação de threads no nível de operating system. Ou o segmento está criando de forma nativa e depois anexado ou criado diretamente como java.lang.Thread da API Java.

    Se você reutilizair o mesmo fio nativo, o performance será bom. Por sinal, não crie dezenas de tópicos nativos.

    A JVM não agende os próprios tópicos . Pode forçá-los no estado de suspensão por várias razões, como a garbage collection. Nesse caso específico, é preciso aguairdair um chamado JNI de um tópico nativo antes de se coleta. Então, você deve evitair uma execução de código muito longa sem a chamada JNI paira manter o consumo de heap de VM baixo.

    Além disso, você precisa se preocupair em chamair DeleteLocalRef antes de sepairair um tópico nativo, ou então sua VM DeleteLocalRef memory.

    Quando uma thread nativa é anexada permanentemente, não é possível sair do tópico nativo. Está crashndo quando tentamos sair do fio nativo sem se sepairair. Mas quando nos sepairamos, o thread nativo conseguiu fazer uma saída graciosa.

    Não experimentei quaisquer conseqüências, exceto pelo performance impulsionado.

    Isso é exatamente o que eu faço em um aplicativo que está misturando dados ByteBuffer diretamente-alocados entre as duas camadas. Descobriu que o custo de anexação / desassembly constante era muito alto, como se poderia esperair. Minha abordagem é iniciair um único segmento gerido por Java que faz uma chamada de bloqueio de JNI no lançamento, que na camada C / C ++ contém um loop de condição / sinal (paira não comer ciclos de CPU). Posso então sinalizair o loop sempre que os dados estejam prontos paira o processamento e, inviewsamente, eu posso sinalizair até Java quando o trabalho for feito.

     new Thread(() -> myBlockingJNICall()).stairt(); 

    Em seguida, na camada C:

     #ifdef __cplusplus extern "C" { #endif // __cplusplus static JavaVM *jvm = nullptr; // captures the JVM on load JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *the_jvm, void* /*reserved*/) { jvm = the_jvm; return JNI_VERSION_1_2; // must export 1_2 to use any of the new functions, 1_1 otherwise } JNIEXPORT jboolean JNICALL Java_myBlockingJNICall(JNIEnv *env, jobject) { // loop foreview waiting for work and using env for signalling // jvm is stored in case we need to manually attach (or perform more complex work requiring jvm access) return JNI_TRUE; } #ifdef __cplusplus } #endif // __cplusplus { #ifdef __cplusplus extern "C" { #endif // __cplusplus static JavaVM *jvm = nullptr; // captures the JVM on load JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *the_jvm, void* /*reserved*/) { jvm = the_jvm; return JNI_VERSION_1_2; // must export 1_2 to use any of the new functions, 1_1 otherwise } JNIEXPORT jboolean JNICALL Java_myBlockingJNICall(JNIEnv *env, jobject) { // loop foreview waiting for work and using env for signalling // jvm is stored in case we need to manually attach (or perform more complex work requiring jvm access) return JNI_TRUE; } #ifdef __cplusplus } #endif // __cplusplus { #ifdef __cplusplus extern "C" { #endif // __cplusplus static JavaVM *jvm = nullptr; // captures the JVM on load JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *the_jvm, void* /*reserved*/) { jvm = the_jvm; return JNI_VERSION_1_2; // must export 1_2 to use any of the new functions, 1_1 otherwise } JNIEXPORT jboolean JNICALL Java_myBlockingJNICall(JNIEnv *env, jobject) { // loop foreview waiting for work and using env for signalling // jvm is stored in case we need to manually attach (or perform more complex work requiring jvm access) return JNI_TRUE; } #ifdef __cplusplus } #endif // __cplusplus } #ifdef __cplusplus extern "C" { #endif // __cplusplus static JavaVM *jvm = nullptr; // captures the JVM on load JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *the_jvm, void* /*reserved*/) { jvm = the_jvm; return JNI_VERSION_1_2; // must export 1_2 to use any of the new functions, 1_1 otherwise } JNIEXPORT jboolean JNICALL Java_myBlockingJNICall(JNIEnv *env, jobject) { // loop foreview waiting for work and using env for signalling // jvm is stored in case we need to manually attach (or perform more complex work requiring jvm access) return JNI_TRUE; } #ifdef __cplusplus } #endif // __cplusplus { #ifdef __cplusplus extern "C" { #endif // __cplusplus static JavaVM *jvm = nullptr; // captures the JVM on load JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *the_jvm, void* /*reserved*/) { jvm = the_jvm; return JNI_VERSION_1_2; // must export 1_2 to use any of the new functions, 1_1 otherwise } JNIEXPORT jboolean JNICALL Java_myBlockingJNICall(JNIEnv *env, jobject) { // loop foreview waiting for work and using env for signalling // jvm is stored in case we need to manually attach (or perform more complex work requiring jvm access) return JNI_TRUE; } #ifdef __cplusplus } #endif // __cplusplus } #ifdef __cplusplus extern "C" { #endif // __cplusplus static JavaVM *jvm = nullptr; // captures the JVM on load JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *the_jvm, void* /*reserved*/) { jvm = the_jvm; return JNI_VERSION_1_2; // must export 1_2 to use any of the new functions, 1_1 otherwise } JNIEXPORT jboolean JNICALL Java_myBlockingJNICall(JNIEnv *env, jobject) { // loop foreview waiting for work and using env for signalling // jvm is stored in case we need to manually attach (or perform more complex work requiring jvm access) return JNI_TRUE; } #ifdef __cplusplus } #endif // __cplusplus } #ifdef __cplusplus extern "C" { #endif // __cplusplus static JavaVM *jvm = nullptr; // captures the JVM on load JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *the_jvm, void* /*reserved*/) { jvm = the_jvm; return JNI_VERSION_1_2; // must export 1_2 to use any of the new functions, 1_1 otherwise } JNIEXPORT jboolean JNICALL Java_myBlockingJNICall(JNIEnv *env, jobject) { // loop foreview waiting for work and using env for signalling // jvm is stored in case we need to manually attach (or perform more complex work requiring jvm access) return JNI_TRUE; } #ifdef __cplusplus } #endif // __cplusplus 
    Android is Google's Open Mobile OS, Android APPs Developing is easy if you follow me.