Android线程的生命周期

刺骨的言语ヽ痛彻心扉 2022-11-22 00:15 272阅读 0赞

## 线程之生命周期 ##

在开发过程中我们用到线程的地方也不少，线程在android源码中也随处。重新整理线程知识，加深对线程的理解。在线程的生命周期中，它要经过新建（New）、就绪（Runnable）、运行（Running）、阻塞（Blocked）和死亡（Dead）五种状态。当线程start后，它不能一直"独占"着CPU独自运行，所以CPU需要在多条线程之间切换，于是线程状态也会多次在运行、阻塞之间切换。按自己的理解整理出一张线程生命周期图，参照生命周期图更直观的了解线程。下面着重分析这五种状态：

1.  新建 New
2.  就绪 Runnable
3.  运行 Running
4.  阻塞 Blocked
5.  死亡 Dead
    
     
    
    ![2af14ee15cfa5ee7f4d8f8c1a0b04ecd.webp][]

### 新建（new） ###

public class XThread extends Thread{
        @Override
            public void run() {
                
            }
    }
    //新建就是new出对象
    XThread thread = new XThread();

> 当程序使用new关键字创建了一个线程之后，该线程就处于一个新建状态（初始状态），此时它和其他Java对象一样，仅仅由Java虚拟机为其分配了内存，并初始化了其成员变量值。此时的线程对象没有表现出任何线程的动态特征，程序也不会执行线程的线程执行体。

### 就绪 Runnable ###

当线程对象调用了Thread.start()方法之后，该线程处于就绪状态，Java虚拟机会为其创建方法调用栈和程序计数器，处于这个状态的线程并没有开始运行，它只是表示该线程可以运行了。从start()源码中看出，start后添加到了线程列表中，接着在native层添加到VM中，至于该线程何时开始运行，取决于JVM里线程调度器的调度(如果OS调度选中了，就会进入到运行状态)。回看一下下面start方法源码：

public synchronized void start() {
            /**
             * This method is not invoked for the main method thread or "system"
             * group threads created/set up by the VM. Any new functionality added
             * to this method in the future may have to also be added to the VM.
             *
             * A zero status value corresponds to state "NEW".
             */
            // Android-changed: throw if 'started' is true
            if (threadStatus != 0 || started)
                throw new IllegalThreadStateException();
    
            /* Notify the group that this thread is about to be started
             * so that it can be added to the group's list of threads
             * and the group's unstarted count can be decremented. */
             //通知组此线程即将启动，以便将其添加到组的线程列表中，并且可以减少组的未启动计数。
            group.add(this);
            started = false;
            try {
                nativeCreate(this, stackSize, daemon);
                started = true;
            } finally {
                try {
                    if (!started) {
                        group.threadStartFailed(this);
                    }
                } catch (Throwable ignore) {
                    /* do nothing. If start0 threw a Throwable then
                      it will be passed up the call stack */
                }
            }
        }

**C/C++中的nativeCreate的源码**

static void Thread_nativeCreate(JNIEnv* env, jclass, jobject java_thread, 
                                      jlong stack_size, jboolean daemon) {
      Thread::CreateNativeThread(env, java_thread, stack_size, daemon == JNI_TRUE);
    }

**C/C++中的CreateNativeThread**

void Thread::CreateNativeThread(JNIEnv* env, jobject java_peer, size_t stack_size, bool is_daemon) {
      Thread* self = static_cast<JNIEnvExt*>(env)->self;
      Runtime* runtime = Runtime::Current();
    
      ...
      Thread* child_thread = new Thread(is_daemon);
      child_thread->tlsPtr_.jpeer = env->NewGlobalRef(java_peer);
      stack_size = FixStackSize(stack_size);
    
      env->SetLongField(java_peer, WellKnownClasses::java_lang_Thread_nativePeer,
                        reinterpret_cast<jlong>(child_thread));
    
      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();
        //创建线程
        pthread_create_result = pthread_create(&new_pthread,
                             &attr, Thread::CreateCallback, child_thread);
    
        if (pthread_create_result == 0) {
          child_jni_env_ext.release();
          return;
        }
      }
      
      ...
    }

**C/C++中的pthread\_create，pthread\_create的分析暂时不分析，涉及到Linux知识代深入了解再分析，先说说pthread\_create的参数吧**

*  原型：int pthread\_create（（pthread\_t *thread, pthread\_attr\_t \*attr, void \*（*start\_routine）（void \*）, void \*arg）
 *  头文件：\#include
 *  输入参数：thread：线程标识符； attr：线程属性设置； start\_routine：线程函数的起始地址； arg：传递给start\_routine的参数；
 *  返回值：成功则返回0；出错则返回-1。
 *  功能：创建线程，并调用线程起始地址所指向的函数start\_routine。

### 运行 Running ###

如果处于就绪状态的线程获得了CPU资源，就开始执行run方法的线程执行体，则该线程处于运行状态。run方法的那里呢？其实run也是在native线程中。源码如下

**C/C++中的Thread.run**

status_t Thread::run(const char* name, int32_t priority, size_t stack)
    {
        Mutex::Autolock _l(mLock);
        //保证只会启动一次
        if (mRunning) {
            return INVALID_OPERATION;
        }
        ...
        mRunning = true;
    
        bool res;
        
        if (mCanCallJava) {
            //还能调用Java代码的Native线程
            res = createThreadEtc(_threadLoop,
                    this, name, priority, stack, &mThread);
        } else {
            //只能调用C/C++代码的Native线程
            res = androidCreateRawThreadEtc(_threadLoop,
                    this, name, priority, stack, &mThread);
        }
    
        if (res == false) {
            ...//清理
            return UNKNOWN_ERROR;
        }
        return NO_ERROR;
    }

mCanCallJava在Thread对象创建时，在构造函数中默认设置mCanCallJava=true.

*  当mCanCallJava=true,则代表创建的是不仅能调用C/C++代码，还能能调用Java代码的Native线程
 *  当mCanCallJava=false,则代表创建的是只能调用C/C++代码的Native线程。

关于createThreadEtc和androidCreateRawThreadEtc方法都不一一列出来了，感兴趣的自已查检源码了解。

从start方法进入nativeCreate经过层层调用，最终都会进入clone系统调用，这是linux创建线程或进程的通用接口。Native线程中是否可以执行Java代码的区别，在于通过javaThreadShell()方法从而实现在\_threadLoop()执行前后增加分别将当前线程增加hook到虚拟机和从虚拟机移除的功能。调用过程，顺序为：

1.Thread.run  
2.createThreadEtc  
3.androidCreateThreadEtc  
4.javaCreateThreadEtc  
5.androidCreateRawThreadEtc  
6.javaThreadShell  
7.javaAttachThread  
8.\_threadLoop  
9.javaDetachThread

### 阻塞 Blocked ###

阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态。阻塞的情况大概三种：

1、**等待阻塞：**运行的线程执行wait()方法，JVM会把该线程放入等待池中。(wait会释放持有的锁)  
2、**同步阻塞：**运行的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池中。  
3、**其他阻塞：**运行的线程执行sleep()或join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。（注意,sleep是不会释放持有的锁）。

**线程睡眠：**Thread.sleep(long millis)方法，使线程转到阻塞状态。millis参数设定睡眠的时间，以毫秒为单位。当睡眠结束后，就转为就绪（Runnable）状态。sleep()平台移植性好。  
**线程等待：**Object类中的wait()方法，导致当前的线程等待，直到其他线程调用此对象的 notify() 方法或 notifyAll() 唤醒方法。这个两个唤醒方法也是Object类中的方法，行为等价于调用 wait(0) 一样。唤醒线程后，就转为就绪（Runnable）状态。  
**线程让步：**Thread.yield() 方法，暂停当前正在执行的线程对象，把执行机会让给相同或者更高优先级的线程。  
**线程加入：**join()方法，等待其他线程终止。在当前线程中调用另一个线程的join()方法，则当前线程转入阻塞状态，直到另一个进程运行结束，当前线程再由阻塞转为就绪状态。  
**线程I/O：**线程执行某些IO操作，因为等待相关的资源而进入了阻塞状态。比如说监听system.in，但是尚且没有收到键盘的输入，则进入阻塞状态。  
**线程唤醒：**Object类中的notify()方法，唤醒在此对象监视器上等待的单个线程。如果所有线程都在此对象上等待，则会选择唤醒其中一个线程，选择是任意性的，并在对实现做出决定时发生。类似的方法还有一个notifyAll()，唤醒在此对象监视器上等待的所有线程。

### 死亡 Dead ###

线程会以以下三种方式之一结束，结束后就处于死亡状态:

1.  run()方法执行完成，线程正常结束。
2.  线程抛出一个未捕获的Exception或Error。
3.  直接调用该线程的stop()方法来结束该线程——该方法容易导致死锁，通常不推荐使用。

作者：安仔夏天勤奋  
链接：https://www.jianshu.com/p/cb6c3090002f  
来源：简书  
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

[2af14ee15cfa5ee7f4d8f8c1a0b04ecd.webp]: /images/20221120/08ff2eca0dc448659b3dccaf7fe11de5.png