Java线程生命周期以及方法详解

前言：现在的操作系统在运行一个程序时， 会为其创建一个进程。  在进程中操作系统调度的最小单元是线程， 也叫轻量级进程（Light Weight Process） ， 在一个进程里可以创建多个线程， 这些线程都拥有各自的计数器、 堆栈和局部变量等属性， 并且能够访问共享的内存变量。 处理器在这些线程上高速切换， 让使用者感觉到这些线程在同时执行。

啰嗦一下进程、线程是什么？

进程是指一个内存中运行的应用程序，每个进程都有自己独立的一块内存空间，一个进程中可以启动多个线程。比如在Windows系统中，一个运行的exe就是一个进程。

线程是指进程中的一个执行流程，一个进程中可以运行多个线程。比如java.exe进程中可以运行很多线程。线程总是属于某个进程，进程中的多个线程共享进程的内存。

线程的生命周期

每个线程都有自己的完整的生命周期，下面通过一张copy的图来详细的了解一下：

从上图我们可以看出线程的生命周期大致可以分为五个阶段：

NEW(新建状态)

当我们new一个Thread对象时，此时它并不处于运行状态，因为还没有调用start方法启动线程。那么线程的NEW状态，其实只是Thread对象的状态，在没有调用start方法之前，该线程根本不存在，和new一个普通的Java对象没什么区别。NEW状态可以通过start方法进入RUNNABLE状态。

RUNNABLE(就绪状态)

线程对象进入RUNNABLE状态必须调用start方法，此时JVM进程中才会真正的创建一个线程，线程启动后并不会立即得到执行。线程是否运行和进程一样都要听从CPU的调度，为此我们把这个中间状态成为就绪状态，也称为可执行状态(RUNNABLE),也就是说它具备执行的资格，但是并没有真正的执行而是在等待CPU的调度。

由于存在Running状态，所以不会直接进人BLOCKED状态和TERMINATED状态，即使是在线程的执行逻辑中调用wait、sleep或者其他block的I0操作等，也必须先获得CPU的调度执行权才可以，严格来讲，RUNNABLE的线程只能意外终止或者进人RUNNING状态。

RUNNING(运行状态)

一旦CPU通过时间片轮转或者其他方式选中了线程，那么此时它才能真正的执行自己的逻辑。这里需要注意的一点是一个正在RUNNING状态的线程其实也是RUNNABLE的，但是反过来则不成立。

在RUNNING状态中，线程的状态可以发生如下的状态转换：

• 直接进人TERMINATED状态，比如调用JDK已经不推荐使用的stop方法或者判断某个逻辑标识。
• 进人BLOCKED状态，比如调用了sleep,或者wait方法而加入了waitSet 中。
• 进行某个阻塞的I0操作，比如因网络数据的读写而进入了BLOCKED状态。
• 获取某个锁资源，从而加入到该锁的阻塞队列中而进人了BLOCKED状态。
• 由于CPU的调度器轮询使该线程放弃执行，进人RUNNABLE状态。
• 线程主动调用yield方法，放弃CPU执行权，进入RUNNABLE状态。

BLOCKED(阻塞状态)

上面列举了线程进入BLOCKED状态的原因，下面我们在列举线程在BLOCKED状态中可能切换的状态：

• 直接进人TERMINATED状态，比如调用JDK已经不推荐使用的stop方法或者意外死亡(JVM Crash)。
• 线程阻塞的操作结束，比如读取了想要的数据字节进人到RUNNABLE状态。
• 线程完成了指定时间的休眠，进人到了RUNNABLE状态。
• Wait中的线程被其他线程notify/notifyall唤醒，进人RUNNABLE状态。
• 线程获取到了某个锁资源，进人RUNNABLE状态。
• 线程在阻塞过程中被打断，比如其他线程调用了interrupt方法，进人RUNNABLE状态。

TERMINATED(死亡状态)

TERMINATED状态是线程最终状态，在该状态的线程不会再切换到其它任何状态，意味着线程的整个生命周期都结束了。

Thread 方法API详解

run和start()

把需要处理的代码放到run()方法中，start()方法启动线程将自动调用run()方法，这个由java的内存机制规定的。并且run()方法必需是public访问权限，返回值类型为void。

sleep()

sleep是一个静态方法，其有两个重载方法，其中一个需要传入毫秒，另外一个既需要毫秒数，还需要纳秒数：
public static native void sleep(long millis) throws InterruptedException;
public static void sleep(long millis, int nanos) throws InterruptedException

该方法使当前线程（即调用该方法的线程）暂停执行一段时间，让其他线程有机会继续执行，但它并不释放对象锁。也就是说如果有synchronized同步快，其他线程仍然不能访问共享数据。

友情提示：该方法要捕捉异常。

例如有两个线程同时执行(没有synchronized)一个线程优先级为MAX_PRIORITY，另一个为MIN_PRIORITY，如果没有Sleep()方法，只有高优先级的线程执行完毕后，低优先级的线程才能够执行；但是高优先级的线程sleep(500)后，低优先级就有机会执行了。

总之，sleep()可以使低优先级的线程得到执行的机会，当然也可以让同优先级、高优先级的线程有执行的机会。

JDK1.5以后，JDK引入了一个枚举TimeUnit，其对sleep做了很好的封装：

//休眠一天
TimeUnit.DAYS.sleep(1);
//休眠一小时
TimeUnit.HOURS.sleep(1);
//休眠一分钟
TimeUnit.MINUTES.sleep(1);
//休眠一秒
TimeUnit.SECONDS.sleep(1);
//休眠一毫秒
TimeUnit.MILLISECONDS.sleep(1);

yield方法

yield也是一个静态方法，调用此方法会提醒调度器我愿意放弃当前的cpu资源，如果CPU资源不紧张的话，调度器可能会忽略这个提醒。操作系统是为每个线程分配一个时间片来占有CPU的，正常情况下当一个线程把分配给自己的时间片使用完后，线程调度器才会进行下一轮的线程调度，而当一个线程调用了Thread类的静态方法yield时，是在告诉线程调度器自己占有的时间片中还没有使用完的部分自己不想使用了，这暗示线程调度器现在就可以进行下一轮的线程调度。

该方法与sleep()类似，只是不能由用户指定暂停多长时间，并且yield（）方法只能让同优先级的线程有执行的机会。

yield()也不会释放锁标志。

sleep 与 yield 方法的区别在于，当线程调用sleep方法时调用线程会被阻塞挂 起指定的时间，在这期间线程调度器不会去调度该线程。而调用yield 方法时，线程只是让出自己剩余的时间片，并没有被阻塞挂起，而是处于就绪状态，线程调度器下一次调度时就有可能调度到当前线程执行 。

sleep 方法允许较低优先级的线程获得运行机会，但yield（）方法执行时，当前线程仍处在可运行状态，所以不可能让出较低优先级的线程此时获取CPU占有权。在一个运行系统中，如果较高优先级的线程没有调用sleep方法，也没有受到I/O阻塞，那么较低优先级线程只能等待所有较高优先级的线程运行结束，方可有机会运行。

总的来说yield()只是使当前线程重新回到可执行状态，所有执行yield()的线程有可能在进入到可执行状态后马上又被执行，所以yield()方法只能使同优先级的线程有执行的机会。

setPriority()&getPriority() 线程优先级

在操作系统中，进程有优先级之分，线程同样也有优先级，理论上优先级高的线程有被CPU优先调度的机会，但真实情况往往并不会如你所愿，因为设置线程优先级也是一个hint(暗示)操作。

• 对于root用户，它会hint操作系统你想要设置的优先级别，否则它会被忽略。
• 在CPU比较忙的情况下，设置优先级可能会获取更多的CPU调度机会，但是闲时优先级的高低一般不会有任何作用。

//简单来看看设置优先级方法的源码
public final void setPriority(int newPriority) {
        ThreadGroup g;
        checkAccess();
        if (newPriority > MAX_PRIORITY || newPriority < MIN_PRIORITY) {
            throw new IllegalArgumentException();
        }
        if((g = getThreadGroup()) != null) {
            if (newPriority > g.getMaxPriority()) {
                newPriority = g.getMaxPriority();
            }
            setPriority0(priority = newPriority);
        }
    }

分析如上代码，可以看出线程的优先级必须是1~10，如果指定的线程优先级大于线程所在的group的优先级，那么会忽略指定的优先级从而获取group的最大优先级。线程默认的优先级和创建它的那个线程保持一致，一般情况下都是5。

获取线程ID getId()

getId()获取线程的唯一ID,线程的ID在整个JVM进程中都是唯一的。

interrupt相关方法

• interrupt()方法：在线程内部存在着名为interrupt flag的标识，如果一个线程调用了interrupt方法，flag会被设置，但是如果当前线程正处于阻塞状态时，调用interrupt，线程将会中断阻塞，并且会抛出InterruptedException异常，这个异常就像是一个signal(信号)一样通知当前线程被打断了，并且flag会被清除。

• isInterrupted()方法：此方法是Thread类的实例方法，主要判断当前线程是否被中断。

• interrupted()方法：此方法是Thread中的一个静态方法，也是主要用于判断当前线程是否被中断，但是它和isInterrupted()方法有个区别就是该方法会直接清除掉该线程的interrupt标识。

join方法

join()方法使调用该方法的线程在此之前执行完毕，也就是等待该方法的线程执行完毕后再往下继续执行。

友情提示：注意该方法也需要捕捉异常。

join方法会使当前线程永远的等待下去，直到期间被另外的线程中断，或者join的线程执行结束，也可以使用另外两个重载方法，指定等待毫秒数，在指定的时间到达之后，当前线程也回退出阻塞。

join() 一直等待
join(long millis) 等待指定毫秒数
join(long millis, int nanos) 等待指定毫秒数

wait()、notify()、notifyAll()

synchronized关键字用于保护共享数据，阻止其他线程对共享数据的存取，但是这样程序的流程就很不灵活了，如何才能在当前线程还没退出synchronized数据块时让其他线程也有机会访问共享数据呢？此时就用这三个方法来灵活控制。

wait()方法使当前线程暂停执行并释放对象锁标示，让其他线程可以进入synchronized数据块，当前线程被放入对象等待池中。当调用notify()方法后，将从对象的等待池中移走一个任意的线程并放到锁标志等待池中，只有锁标志等待池中线程能够获取锁标志；如果锁标志等待池中没有线程，则notify()不起作用。

notifyAll()则从对象等待池中移走所有等待那个对象的线程并放到锁标志等待池中。

常用的wait方法：

• void wait() 在其他线程调用此对象的 notify() 方法或者 notifyAll()方法前，导致当前线程等待。
• void wait(long timeout)在其他线程调用此对象的notify() 方法 或者 notifyAll()方法，或者超过指定的时间量前，导致当前线程等待。

友情提示1：这三个方法都是java.lang.Object的方法。

友情提示2：这三个方法用于协调多个线程对共享数据的存取，所以必须在synchronized语句块内使用。wait()h和notify()因为会对对象的“锁标志”进行操作，所以他们必需在Synchronized函数或者 synchronized block 中进行调用。如果在non-synchronized 函数或 non-synchronized block 中进行调用，虽然能编译通过，但在运行时会发生IllegalMonitorStateException的异常。

关键字synchronized

该关键字用于保护共享数据，当然前提条件是要分清哪些数据是共享数据。每个对象都有一个锁标志，当一个线程访问到该对象，被Synchronized修饰的数据将被"上锁"，阻止其他线程访问。当前线程访问完这部分数据后释放锁标志，其他线程就可以访问了。

欲知此关键字的更过内容请点击下方传送门：

关键字synchronized

到此，see  you