JNI_CreateJavaVM 사용 못함 ...

jni.h 보니깡 아래와 같이 생겼네요..ㅠㅠ

http://stackoverflow.com/questions/8145985/android-ndk-cant-find-jni-getcreatedjavavms-after-update-from-r6-to-r7

/*
 * VM initialization functions.
 *
 * Note these are the only symbols exported for JNI by the VM.
 */
#if 0  /* In practice, these are not exported by the NDK so don't declare them */
jint JNI_GetDefaultJavaVMInitArgs(void*);
jint JNI_CreateJavaVM(JavaVM**, JNIEnv**, void*);
jint JNI_GetCreatedJavaVMs(JavaVM**, jsize, jsize*);
#endif

아아... 무서운 declare...

해결했습니다. ^^

davik thread정책을 보고 힌트를 얻어서 

vm-> AttachCurrentThread() 와 vm-> DetachCurrentThread() 를 타이트 하게 관리 했는데

vm-> AttachCurrentThread() 하였다고 무족건 vm-> DetachCurrentThread()  하면 안됩니다.

반듯이 Thread save 상황에서 AttachCurrentThread ~ DetachCurrentThread 가 한 세트가 되어야 하는군요..
스레드 카운트 해서 env 관리 하는거 같습니다. 2개까지 인정해 주는군요.. 

아래 thread.c 소스~~!!

/*
  * Attach the current thread to the VM.
  *
  * Used for internally-created threads and JNI's AttachCurrentThread.
  */
 bool dvmAttachCurrentThread(const JavaVMAttachArgs* pArgs, bool isDaemon)
 {
     Thread* self = NULL;
     Object* threadObj = NULL;
     Object* vmThreadObj = NULL;
     StringObject* threadNameStr = NULL;
     Method* init;
     bool ok, ret;
 
     /* establish a basic sense of self */
     self = allocThread(gDvm.stackSize);
     if (self == NULL)
         goto fail;
     setThreadSelf(self);
 
     /*
      * Create Thread and VMThread objects.  We have to use ALLOC_NO_GC
      * because this thread is not yet visible to the VM.  We could also
      * just grab the GC lock earlier, but that leaves us executing
      * interpreted code with the lock held, which is not prudent.
      *
      * The alloc calls will block if a GC is in progress, so we don't need
      * to check for global suspension here.
      *
      * It's also possible for the allocation calls to *cause* a GC.
      */
     //BUG: deadlock if a GC happens here during HeapWorker creation
     threadObj = dvmAllocObject(gDvm.classJavaLangThread, ALLOC_NO_GC);
     if (threadObj == NULL)
         goto fail;
     vmThreadObj = dvmAllocObject(gDvm.classJavaLangVMThread, ALLOC_NO_GC);
     if (vmThreadObj == NULL)
         goto fail;
 
     self->threadObj = threadObj;
     dvmSetFieldInt(vmThreadObj, gDvm.offJavaLangVMThread_vmData, (u4)self);
 
     /*
      * Do some java.lang.Thread constructor prep before we lock stuff down.
      */
     if (pArgs->name != NULL) {
         threadNameStr = dvmCreateStringFromCstr(pArgs->name, ALLOC_NO_GC);
         if (threadNameStr == NULL) {
             assert(dvmCheckException(dvmThreadSelf()));
             goto fail;
         }
     }
 
     init = dvmFindDirectMethodByDescriptor(gDvm.classJavaLangThread, "<init>",
             "(Ljava/lang/ThreadGroup;Ljava/lang/String;IZ)V");
     if (init == NULL) {
         assert(dvmCheckException(dvmThreadSelf()));
         goto fail;
     }
 
     /*
      * Finish our thread prep.  We need to do this before invoking any
      * interpreted code.  prepareThread() requires that we hold the thread
      * list lock.
      */
     dvmLockThreadList(self);
     ok = prepareThread(self);
     dvmUnlockThreadList();
     if (!ok)
         goto fail;
 
     self->jniEnv = dvmCreateJNIEnv(self);
     if (self->jniEnv == NULL)
         goto fail;
 
     /*
      * Create a "fake" JNI frame at the top of the main thread interp stack.
      * It isn't really necessary for the internal threads, but it gives
      * the debugger something to show.  It is essential for the JNI-attached
      * threads.
      */
     if (!createFakeRunFrame(self))
         goto fail;
 
     /*
      * The native side of the thread is ready;  add it to the list.
      */
     LOG_THREAD("threadid=%d: adding to list (attached)\n", self->threadId);
 
     /* Start off in VMWAIT, because we may be about to block
      * on the heap lock, and we don't want any suspensions
      * to wait for us.
      */
     self->status = THREAD_VMWAIT;
 
     /*
      * Add ourselves to the thread list.  Once we finish here we are
      * visible to the debugger and the GC.
      */
     dvmLockThreadList(self);
 
     self->next = gDvm.threadList->next;
     if (self->next != NULL)
         self->next->prev = self;
     self->prev = gDvm.threadList;
     gDvm.threadList->next = self;
     if (!isDaemon)
         gDvm.nonDaemonThreadCount++;
 
     dvmUnlockThreadList();
 
     /*
      * It's possible that a GC is currently running.  Our thread
      * wasn't in the list when the GC started, so it's not properly
      * suspended in that case.  Synchronize on the heap lock (held
      * when a GC is happening) to guarantee that any GCs from here
      * on will see this thread in the list.
      */
     dvmLockMutex(&gDvm.gcHeapLock);
     dvmUnlockMutex(&gDvm.gcHeapLock);
 
     /*
      * Switch to the running state now that we're ready for
      * suspensions.  This call may suspend.
      */
     dvmChangeStatus(self, THREAD_RUNNING);
 
     /*
      * Now we're ready to run some interpreted code.
      *
      * We need to construct the Thread object and set the VMThread field.
      * Setting VMThread tells interpreted code that we're alive.
      *
      * Call the (group, name, priority, daemon) constructor on the Thread.
      * This sets the thread's name and adds it to the specified group, and
      * provides values for priority and daemon (which are normally inherited
      * from the current thread).
      */
     JValue unused;
     dvmCallMethod(self, init, threadObj, &unused, (Object*)pArgs->group,
         threadNameStr, getThreadPriorityFromSystem(), isDaemon);
     if (dvmCheckException(self)) {
         LOGE("exception thrown while constructing attached thread object\n");
         goto fail_unlink;
     }
     //if (isDaemon)
     //    dvmSetFieldBoolean(threadObj, gDvm.offJavaLangThread_daemon, true);
 
     /*
      * Set the VMThread field, which tells interpreted code that we're alive.
      *
      * The risk of a thread start collision here is very low; somebody
      * would have to be deliberately polling the ThreadGroup list and
      * trying to start threads against anything it sees, which would
      * generally cause problems for all thread creation.  However, for
      * correctness we test "vmThread" before setting it.
      */
     if (dvmGetFieldObject(threadObj, gDvm.offJavaLangThread_vmThread) != NULL) {
         dvmThrowException("Ljava/lang/IllegalThreadStateException;",
             "thread has already been started");
         /* We don't want to free anything associated with the thread
          * because someone is obviously interested in it.  Just let
          * it go and hope it will clean itself up when its finished.
          * This case should never happen anyway.
          *
          * Since we're letting it live, we need to finish setting it up.
          * We just have to let the caller know that the intended operation
          * has failed.
          *
          * [ This seems strange -- stepping on the vmThread object that's
          * already present seems like a bad idea.  TODO: figure this out. ]
          */
         ret = false;
     } else
         ret = true;
     dvmSetFieldObject(threadObj, gDvm.offJavaLangThread_vmThread, vmThreadObj);
 
     /* These are now reachable from the thread groups. */
     dvmClearAllocFlags(threadObj, ALLOC_NO_GC);
     dvmClearAllocFlags(vmThreadObj, ALLOC_NO_GC);
 
     /*
      * The thread is ready to go;  let the debugger see it.
      */
     self->threadObj = threadObj;
 
     LOG_THREAD("threadid=%d: attached from native, name=%s\n",
         self->threadId, pArgs->name);
 
     /* tell the debugger & DDM */
     if (gDvm.debuggerConnected)
         dvmDbgPostThreadStart(self);
 
     return ret;
 
 fail_unlink:
     dvmLockThreadList(self);
     unlinkThread(self);
     if (!isDaemon)
         gDvm.nonDaemonThreadCount--;
     dvmUnlockThreadList();
     /* fall through to "fail" */
 fail:
     dvmClearAllocFlags(threadObj, ALLOC_NO_GC);
     dvmClearAllocFlags(vmThreadObj, ALLOC_NO_GC);
     if (self != NULL) {
         if (self->jniEnv != NULL) {
             dvmDestroyJNIEnv(self->jniEnv);
             self->jniEnv = NULL;
         }
         freeThread(self);
     }
     setThreadSelf(NULL);
     return false;
 }
 
 /*
  * Detach the thread from the various data structures, notify other threads
  * that are waiting to "join" it, and free up all heap-allocated storage.
  *
  * Used for all threads.
  *
  * When we get here the interpreted stack should be empty.  The JNI 1.6 spec
  * requires us to enforce this for the DetachCurrentThread call, probably
  * because it also says that DetachCurrentThread causes all monitors
  * associated with the thread to be released.  (Because the stack is empty,
  * we only have to worry about explicit JNI calls to MonitorEnter.)
  *
  * THOUGHT:
  * We might want to avoid freeing our internal Thread structure until the
  * associated Thread/VMThread objects get GCed.  Our Thread is impossible to
  * get to once the thread shuts down, but there is a small possibility of
  * an operation starting in another thread before this thread halts, and
  * finishing much later (perhaps the thread got stalled by a weird OS bug).
  * We don't want something like Thread.isInterrupted() crawling through
  * freed storage.  Can do with a Thread finalizer, or by creating a
  * dedicated ThreadObject class for java/lang/Thread and moving all of our
  * state into that.
  */
 void dvmDetachCurrentThread(void)
 {
     Thread* self = dvmThreadSelf();
     Object* vmThread;
     Object* group;
 
     /*
      * Make sure we're not detaching a thread that's still running.  (This
      * could happen with an explicit JNI detach call.)
      *
      * A thread created by interpreted code will finish with a depth of
      * zero, while a JNI-attached thread will have the synthetic "stack
      * starter" native method at the top.
      */
     int curDepth = dvmComputeExactFrameDepth(self->curFrame);
     if (curDepth != 0) {
         bool topIsNative = false;
 
         if (curDepth == 1) {
             /* not expecting a lingering break frame; just look at curFrame */
             assert(!dvmIsBreakFrame(self->curFrame));
             StackSaveArea* ssa = SAVEAREA_FROM_FP(self->curFrame);
             if (dvmIsNativeMethod(ssa->method))
                 topIsNative = true;
         }
 
         if (!topIsNative) {
             LOGE("ERROR: detaching thread with interp frames (count=%d)\n",
                 curDepth);
             dvmDumpThread(self, false);
             dvmAbort();
         }
     }
 
     group = dvmGetFieldObject(self->threadObj, gDvm.offJavaLangThread_group);
     LOG_THREAD("threadid=%d: detach (group=%p)\n", self->threadId, group);
 
     /*
      * Release any held monitors.  Since there are no interpreted stack
      * frames, the only thing left are the monitors held by JNI MonitorEnter
      * calls.
      */
     dvmReleaseJniMonitors(self);
 
     /*
      * Do some thread-exit uncaught exception processing if necessary.
      */
     if (dvmCheckException(self))
         threadExitUncaughtException(self, group);
 
     /*
      * Remove the thread from the thread group.
      */
     if (group != NULL) {
         Method* removeThread =
             group->clazz->vtable[gDvm.voffJavaLangThreadGroup_removeThread];
         JValue unused;
         dvmCallMethod(self, removeThread, group, &unused, self->threadObj);
     }
 
     /*
      * Clear the vmThread reference in the Thread object.  Interpreted code
      * will now see that this Thread is not running.  As this may be the
      * only reference to the VMThread object that the VM knows about, we
      * have to create an internal reference to it first.
      */
     vmThread = dvmGetFieldObject(self->threadObj,
                     gDvm.offJavaLangThread_vmThread);
     dvmAddTrackedAlloc(vmThread, self);
     dvmSetFieldObject(self->threadObj, gDvm.offJavaLangThread_vmThread, NULL);
 
     /* clear out our struct Thread pointer, since it's going away */
     dvmSetFieldObject(vmThread, gDvm.offJavaLangVMThread_vmData, NULL);
 
     /*
      * Tell the debugger & DDM.  This may cause the current thread or all
      * threads to suspend.
      *
      * The JDWP spec is somewhat vague about when this happens, other than
      * that it's issued by the dying thread, which may still appear in
      * an "all threads" listing.
      */
     if (gDvm.debuggerConnected)
         dvmDbgPostThreadDeath(self);
 
     /*
      * Thread.join() is implemented as an Object.wait() on the VMThread
      * object.  Signal anyone who is waiting.
      */
     dvmLockObject(self, vmThread);
     dvmObjectNotifyAll(self, vmThread);
     dvmUnlockObject(self, vmThread);
 
     dvmReleaseTrackedAlloc(vmThread, self);
     vmThread = NULL;
 
     /*
      * We're done manipulating objects, so it's okay if the GC runs in
      * parallel with us from here out.  It's important to do this if
      * profiling is enabled, since we can wait indefinitely.
      */
     self->status = THREAD_VMWAIT;
 
 #ifdef WITH_PROFILER
     /*
      * If we're doing method trace profiling, we don't want threads to exit,
      * because if they do we'll end up reusing thread IDs.  This complicates
      * analysis and makes it impossible to have reasonable output in the
      * "threads" section of the "key" file.
      *
      * We need to do this after Thread.join() completes, or other threads
      * could get wedged.  Since self->threadObj is still valid, the Thread
      * object will not get GCed even though we're no longer in the ThreadGroup
      * list (which is important since the profiling thread needs to get
      * the thread's name).
      */
     MethodTraceState* traceState = &gDvm.methodTrace;
 
     dvmLockMutex(&traceState->startStopLock);
     if (traceState->traceEnabled) {
         LOGI("threadid=%d: waiting for method trace to finish\n",
             self->threadId);
         while (traceState->traceEnabled) {
             int cc;
             cc = pthread_cond_wait(&traceState->threadExitCond,
                     &traceState->startStopLock);
             assert(cc == 0);
         }
     }
     dvmUnlockMutex(&traceState->startStopLock);
 #endif
 
     dvmLockThreadList(self);
 
     /*
      * Lose the JNI context.
      */
     dvmDestroyJNIEnv(self->jniEnv);
     self->jniEnv = NULL;
 
     self->status = THREAD_ZOMBIE;
 
     /*
      * Remove ourselves from the internal thread list.
      */
     unlinkThread(self);
 
     /*
      * If we're the last one standing, signal anybody waiting in
      * DestroyJavaVM that it's okay to exit.
      */
     if (!dvmGetFieldBoolean(self->threadObj, gDvm.offJavaLangThread_daemon)) {
         gDvm.nonDaemonThreadCount--;        // guarded by thread list lock
 
         if (gDvm.nonDaemonThreadCount == 0) {
             int cc;
 
             LOGV("threadid=%d: last non-daemon thread\n", self->threadId);
             //dvmDumpAllThreads(false);
             // cond var guarded by threadListLock, which we already hold
             cc = pthread_cond_signal(&gDvm.vmExitCond);
             assert(cc == 0);
         }
     }
 
     LOGV("threadid=%d: bye!\n", self->threadId);
     releaseThreadId(self);
     dvmUnlockThreadList();
 
     setThreadSelf(NULL);
     freeThread(self);
 }