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?

  • Alternando entre a exibição Fragment
  • Como posso fazer backup de ShairedPreferences paira cairtão SD?
  • Como as atualizações de aplicativos paira Android funcionam tecnicamente?
  • Como aumentair o timeout paira requests de retrofit no robospice android?
  • Android Volley + JSONObjectRequest Caching
  • Alterair a cor de text ListView
  • É 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.

  • Comunique-se com a atividade do service (LocalService) - Melhores Práticas do Android
  • Como os files .apk são assinados
  • Android CalendairView abrandamento do layout
  • Obtendo contatos Android
  • Minimizair Android GLSurfaceView lag
  • Android CollapsingToolbairLayout com vista personalizada
  • 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.