Android ART虚拟机中的线程管理（七）

清疚 2022-05-31 11:53 422阅读 0赞

一，线程的创建

在java代码中可以有多种方式创建一个线程，常用的方法是：

Thread thd = new Thread();

这个创建会调用init,init2初始化一个线程：

libcore/ojluni/src/main/java/java/lang/Thread.java

private void init(ThreadGroup g, Runnable target, String name, long stackSize) {
            Thread parent = currentThread();
            ...
            init2(parent);
            tid = nextThreadID();
        }

private void init2(Thread parent) {
            this.contextClassLoader = parent.getContextClassLoader();
            this.inheritableThreadLocals = ThreadLocal.createInheritedMap(
                    parent.inheritableThreadLocals);
        }

new 一个Thread对象，其实新线程并没有被创建出来，而是要等到Thread.start()被调用才会新起线程。

public synchronized void start() {
            started = false;
            try {
                nativeCreate(this, stackSize, daemon);
                started = true;
            } finally {
            }
        }

通过nativeCreate()，java层的Thread类最终关联的是native层中的Thread.cc

art/runtime/Thread.cc

void Thread::CreateNativeThread(JNIEnv* env, jobject java_peer, size_t stack_size, bool is_daemon) {
      CHECK(java_peer != nullptr);
      Thread* self = static_cast<JNIEnvExt*>(env)->self;
      Runtime* runtime = Runtime::Current();
      // Atomically start the birth of the thread ensuring the runtime isn't shutting down.
      bool thread_start_during_shutdown = false;
      {
        MutexLock mu(self, *Locks::runtime_shutdown_lock_);
        if (runtime->IsShuttingDownLocked()) {
          thread_start_during_shutdown = true;
        } else {
          runtime->StartThreadBirth();
        }
      }
    
      Thread* child_thread = new Thread(is_daemon);
      
      // Try to allocate a JNIEnvExt for the thread. We do this here as we might be out of memory and
      // do not have a good way to report this on the child's side.
      std::unique_ptr<JNIEnvExt> child_jni_env_ext(
          JNIEnvExt::Create(child_thread, Runtime::Current()->GetJavaVM()));
    
      int pthread_create_result = 0;
      if (child_jni_env_ext.get() != nullptr) {
        pthread_t new_pthread;
        pthread_attr_t attr;
        child_thread->tlsPtr_.tmp_jni_env = child_jni_env_ext.get();
        CHECK_PTHREAD_CALL(pthread_attr_init, (&attr), "new thread");
        CHECK_PTHREAD_CALL(pthread_attr_setdetachstate, (&attr, PTHREAD_CREATE_DETACHED),
                           "PTHREAD_CREATE_DETACHED");
        CHECK_PTHREAD_CALL(pthread_attr_setstacksize, (&attr, stack_size), stack_size);
        pthread_create_result = pthread_create(&new_pthread,
                                               &attr,
                                               Thread::CreateCallback,
                                               child_thread);
        CHECK_PTHREAD_CALL(pthread_attr_destroy, (&attr), "new thread");
      }
    
      // Either JNIEnvExt::Create or pthread_create(3) failed, so clean up.
      {
        MutexLock mu(self, *Locks::runtime_shutdown_lock_);
        runtime->EndThreadBirth();
      }
    }

StartThreadBirth,EndThreadBirth是配套使用的，表示当前有新线程在孵化中。

接下来通过Thread\* child\_thread = new Thread(is\_daemon);创建一个新的线程类，但是真正fork一个线程的地方，还是系统调用pthread\_create函数。

bionic/libc/bionic/Pthread\_create.cpp

int pthread_create(pthread_t* thread_out, pthread_attr_t const* attr,
                       void* (*start_routine)(void*), void* arg) {
    }

其中第一个参数是指向线程标志符的指针；第二个参数线程的属性值；第三个参数是新线程的入口地址；第四个参数是新线程入口函数所需的参数。

art/runtime/Thread.cc

void* Thread::CreateCallback(void* arg) {
      Thread* self = reinterpret_cast<Thread*>(arg);
      Runtime* runtime = Runtime::Current();
      {
        // Note: given that the JNIEnv is created in the parent thread, the only failure point here is
        //       a mess in InitStackHwm. We do not have a reasonable way to recover from that, so abort
        //       the runtime in such a case. In case this ever changes, we need to make sure here to
        //       delete the tmp_jni_env, as we own it at this point.
        CHECK(self->Init(runtime->GetThreadList(), runtime->GetJavaVM(), self->tlsPtr_.tmp_jni_env));
        self->tlsPtr_.tmp_jni_env = nullptr;
        Runtime::Current()->EndThreadBirth();
      }
      {
        // Invoke the 'run' method of our java.lang.Thread.
        mirror::Object* receiver = self->tlsPtr_.opeer;
        jmethodID mid = WellKnownClasses::java_lang_Thread_run;
        ScopedLocalRef<jobject> ref(soa.Env(), soa.AddLocalReference<jobject>(receiver));
        InvokeVirtualOrInterfaceWithJValues(soa, ref.get(), mid, nullptr);
      }
      // Detach and delete self.
      Runtime::Current()->GetThreadList()->Unregister(self);
      return nullptr;
    }

其中的参数arg就是CreateNativeThread()中的创建的Thread类对象，CreateCallback这个函数执行完，一个新的线程就起来了。

这个函数主要做了那些事情？

１）self->init的调用，将其纳入虚拟机的统一管理。

２）准备函数InvokeVirtualOrInterfaceWithJValues需要的参数，其中的参数mid表示java函数的ID号，这里的赋值是：jmethodID mid = WellKnownClasses::java\_lang\_Thread\_run;也就是Thread的run方法。WellKnownClasses这个类是一个基础类，他会通过进一步的调用通过ClassLinker来完成函数的查找。

３）执行新线程承载任务的代码，也就是在native层调用并执行java层中的run函数，这个CreateCallBack是怎么找到run函数对应的代码的？这就是InvokeVirtualOrInterfaceWithJValues完成的工作。

art/runtime/Reflection.cc

JValue InvokeVirtualOrInterfaceWithJValues(const ScopedObjectAccessAlreadyRunnable& soa,
                                               jobject obj, jmethodID mid, jvalue* args) {
      mirror::Object* receiver = soa.Decode<mirror::Object*>(obj);
      ArtMethod* method = FindVirtualMethod(receiver, soa.DecodeMethod(mid));
      bool is_string_init = method->GetDeclaringClass()->IsStringClass() && method->IsConstructor();
      if (is_string_init) {
        // Replace calls to String.<init> with equivalent StringFactory call.
        method = soa.DecodeMethod(WellKnownClasses::StringInitToStringFactoryMethodID(mid));
        receiver = nullptr;
      }
      uint32_t shorty_len = 0;
      const char* shorty = method->GetInterfaceMethodIfProxy(sizeof(void*))->GetShorty(&shorty_len);
      JValue result;
      ArgArray arg_array(shorty, shorty_len);
      arg_array.BuildArgArrayFromJValues(soa, receiver, args);
      InvokeWithArgArray(soa, method, &arg_array, &result, shorty);
      return result;
    }

通过FindVirtualMethod查找到正确的artMethod，ＡrtMethod是虚拟机内部对函数的描述。然后调用InvokeWithArgArray执行查找到的函数。

二，线程的挂起

比如在执行GC时，通常需要把所有线程挂起。

art/runtime/Thread\_list.cc

void ThreadList::SuspendAll(const char* cause, bool long_suspend) {
      Thread* self = Thread::Current();
      {
        ScopedTrace trace("Suspending mutator threads");
        const uint64_t start_time = NanoTime();
    
        SuspendAllInternal(self, self);
        // All threads are known to have suspended (but a thread may still own the mutator lock)
        // Make sure this thread grabs exclusive access to the mutator lock and its protected data.
    #if HAVE_TIMED_RWLOCK
        while (true) {
          if (Locks::mutator_lock_->ExclusiveLockWithTimeout(self, kThreadSuspendTimeoutMs, 0)) {
            break;
          } else if (!long_suspend_) {
            // Reading long_suspend without the mutator lock is slightly racy, in some rare cases, this
            // could result in a thread suspend timeout.
            // Timeout if we wait more than kThreadSuspendTimeoutMs seconds.
            UnsafeLogFatalForThreadSuspendAllTimeout();
          }
        }
    #else
        Locks::mutator_lock_->ExclusiveLock(self);
    #endif
    
        long_suspend_ = long_suspend;
        const uint64_t end_time = NanoTime();
        const uint64_t suspend_time = end_time - start_time;
        suspend_all_historam_.AdjustAndAddValue(suspend_time);
      }
    }

Thread\_list是当前虚拟机中管理的线程的集合，SuspendAllInternal会挂起所有运行着的线程，没有运行的线程不要启动。

做法是给各个线程设置suspend-reques flag使其进入挂起状态，也即是kSuspendRequest，这个判断线程是否挂起的函数中一个参考值。

对线程挂起的管理主要利用mutator\_lock控制，这是一个读写锁。