java（98）
一、线程的生命周期
线程状态转换图：
1、新建状态
用new关键字和Thread类或其子类建立一个线程对象后，该线程对象就处于新生状态。处于新生状态的线程有自己的内存空间，通过调用start方法进入就绪状态（）。
注意：不能对已经启动的线程再次调用start()方法，否则会出现java.lang.IllegalThreadStateException异常。
2、就绪状态
处于就绪状态的线程已经具备了运行条件，但还没有分配到，处于线程就绪队列（尽管是采用队列形式，事实上，把它称为可运行池而不是可运行队列。因为cpu的调度不一定是按照先进先出的顺序来调度的），等待系统为其分配CPU。等待状态并不是执行状态，当系统选定一个等待执行的Thread对象后，它就会从等待执行状态进入执行状态，系统挑选的动作称之为“cpu调度”。一旦获得CPU，线程就进入运行状态并自动调用自己的run方法。
提示：如果希望子线程调用start()方法后立即执行，可以使用Thread.sleep()方式使主线程睡眠一伙儿，转去执行子线程。
3、运行状态
处于运行状态的线程最为复杂，它可以变为阻塞状态、就绪状态和死亡状态。
处于就绪状态的线程，如果获得了cpu的调度，就会从就绪状态变为运行状态，执行run()方法中的任务。如果该线程失去了cpu资源，就会又从运行状态变为就绪状态。重新等待系统分配资源。也可以对在运行状态的线程调用yield()方法，它就会让出cpu资源，再次变为就绪状态。
当发生如下情况是，线程会从运行状态变为阻塞状态：
①、线程调用sleep方法主动放弃所占用的系统资源
②、线程调用一个阻塞式IO方法，在该方法返回之前，该线程被阻塞
③、线程试图获得一个同步监视器，但更改同步监视器正被其他线程所持有
④、线程在等待某个通知（notify）
⑤、程序调用了线程的suspend方法将线程挂起。不过该方法容易导致死锁，所以程序应该尽量避免使用该方法。
当线程的run()方法执行完，或者被强制性地终止，例如出现异常，或者调用了stop()、desyory()方法等等，就会从运行状态转变为死亡状态。
4、阻塞状态
处于运行状态的线程在某些情况下，如执行了（睡眠）方法，或等待设备等资源，将让出并暂时停止自己的运行，进入阻塞状态。&
在阻塞状态的线程不能进入就绪队列。只有当引起阻塞的原因消除时，如睡眠时间已到，或等待的设备空闲下来，线程便转入就绪状态，重新到就绪队列中排队等待，被系统选中后从原来停止的位置开始继续运行。有三种方法可以暂停执行：
5、死亡状态
当线程的run()方法执行完，或者被强制性地终止，就认为它死去。这个线程对象也许是活的，但是，它已经不是一个单独执行的线程。线程一旦死亡，就不能复生。 如果在一个死去的线程上调用start()方法，会抛出java.lang.IllegalThreadStateException异常。
二、线程状态的控制
Java提供了一些便捷的方法用于会线程状态的控制。
&&&&&&&&&&已过时。&该方法最初用于破坏该线程，但不作任何清除。它所保持的任何监视器都会保持锁定状态。不过，该方法决不会被实现。即使要实现，它也极有可能以&方式被死锁。如果目标线程被破坏时保持一个保护关键系统资源的锁，则任何线程在任何时候都无法再次访问该资源。如果另一个线程曾试图锁定该资源，则会出现死锁。这类死锁通常会证明它们自己是“冻结”的进程。有关更多信息，请参阅。
&&&&&&&&&&中断线程。
&&&&&&&&&&等待该线程终止。
(long&millis)
&&&&&&&&&&等待该线程终止的时间最长为&millis&毫秒。
(long&millis, int&nanos)
&&&&&&&&&&等待该线程终止的时间最长为&millis&毫秒 +&nanos&纳秒。
&&&&&&&&&&已过时。&该方法只与&&一起使用，但&&已经遭到反对，因为它具有死锁倾向。有关更多信息，请参阅。
(boolean&on)
&&&&&&&&&&将该线程标记为守护线程或用户线程。
(int&newPriority)
&&&&&&&&&&更改线程的优先级。
static&void
(long&millis)
&&&&&&&&&&在指定的毫秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响。
static&void
(long&millis, int&nanos)
&&&&&&&&&&在指定的毫秒数加指定的纳秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响。
&&&&&&&&&&使该线程开始执行；Java 虚拟机调用该线程的&run&方法。
&&&&&&&&&&已过时。&该方法具有固有的不安全性。用 Thread.stop 来终止线程将释放它已经锁定的所有监视器（作为沿堆栈向上传播的未检查ThreadDeath&异常的一个自然后果）。如果以前受这些监视器保护的任何对象都处于一种不一致的状态，则损坏的对象将对其他线程可见，这有可能导致任意的行为。stop&的许多使用都应由只修改某些变量以指示目标线程应该停止运行的代码来取代。目标线程应定期检查该变量，并且如果该变量指示它要停止运行，则从其运行方法依次返回。如果目标线程等待很长时间（例如基于一个条件变量），则应使用interrupt&方法来中断该等待。有关更多信息，请参阅。
&&&&&&&&&&已过时。&该方法具有固有的不安全性。有关详细信息，请参阅&。该方法的附加危险是它可用于生成目标线程未准备处理的异常（包括若没有该方法该线程不太可能抛出的已检查的异常）。有关更多信息，请参阅。
&&&&&&&&&&已过时。&该方法已经遭到反对，因为它具有固有的死锁倾向。如果目标线程挂起时在保护关键系统资源的监视器上保持有锁，则在目标线程重新开始以前任何线程都不能访问该资源。如果重新开始目标线程的线程想在调用resume&之前锁定该监视器，则会发生死锁。这类死锁通常会证明自己是“冻结”的进程。有关更多信息，请参阅。
static&void
&&&&&&&&&&暂停当前正在执行的线程对象，并执行其他线程。
可以看到很多方法，已经标注为过时的，我们应该尽可能的避免使用它们，而应该重点关注start()、interrupt()、join()、sleep()、yield()等直接控制方法，和setDaemon()、setPriority()等间接控制方法。
1、线程睡眠——sleep
如果我们需要让当前正在执行的线程暂停一段时间，并进入阻塞状态，则可以通过调用Thread的sleep方法，从上面可以看到sleep方法有两种重载的形式，但是使用方法一样。
比如，我们想要使主线程每休眠100毫秒，然后再打印出数字：
可以明显看到打印的数字在时间上有些许的间隔。
注意如下几点问题
①、sleep是静态方法，最好不要用Thread的实例对象调用它，因为它睡眠的始终是当前正在运行的线程，而不是调用它的线程对象，它只对正在运行状态的线程对象有效。看下面的例子：
②、Java线程调度是Java多线程的核心，只有良好的调度，才能充分发挥系统的性能，提高程序的执行效率。但是不管程序员怎么编写调度，只能最大限度的影响线程执行的次序，而不能做到精准控制。因为使用sleep方法之后，线程是进入阻塞状态的，只有当睡眠的时间结束，才会重新进入到就绪状态，而就绪状态进入到运行状态，是由系统控制的，我们不可能精准的去干涉它，所以如果调用Thread.sleep(1000)使得线程睡眠1秒，可能结果会大于1秒。
看某一次的运行结果：
可以看到，线程0首先执行，然后线程1执行一次，又了执行一次。可以看到它并不是按照sleep的顺序执行的。
2、线程让步——yield
yield()方法和sleep()方法有点相似，它也是Thread类提供的一个静态的方法，它也可以让当前正在执行的线程暂停，让出cpu资源给其他的线程。但是和sleep()方法不同的是，它不会进入到阻塞状态，而是进入到就绪状态。yield()方法只是让当前线程暂停一下，重新进入就绪的线程池中，让系统的线程调度器重新调度器重新调度一次，完全可能出现这样的情况：当某个线程调用yield()方法之后，线程调度器又将其调度出来重新进入到运行状态执行。
实际上，当某个线程调用了yield()方法暂停之后，优先级与当前线程相同，或者优先级比当前线程更高的就绪状态的线程更有可能获得执行的机会，当然，只是有可能，因为我们不可能精确的干涉cpu调度线程。
yield的用法：
关于sleep()方法和yield()方的区别如下：
①、sleep方法暂停当前线程后，会进入阻塞状态，只有当睡眠时间到了，才会转入就绪状态。而yield方法调用后 ，是直接进入就绪状态，所以有可能刚进入就绪状态，又被调度到运行状态。
②、sleep方法声明抛出了InterruptedException，所以调用sleep方法的时候要捕获该异常，或者显示声明抛出该异常。而yield方法则没有声明抛出任务异常。
③、sleep方法比yield方法有更好的可移植性，通常不要依靠yield方法来控制并发线程的执行。
3、线程合并——join
线程的合并的含义就是将几个并行线程的线程合并为一个单线程执行，应用场景是当一个线程必须等待另一个线程执行完毕才能执行时，Thread类提供了join方法来完成这个功能，注意，它不是静态方法。
从上面的方法的列表可以看到，它有3个重载的方法：
void&join()&&&&
&&& 当前线程等该加入该线程后面，等待该线程终止。&&&&
void&join(long&millis)&&&&
&&& 当前线程等待该线程终止的时间最长为 millis 毫秒。 如果在millis时间内，该线程没有执行完，那么当前线程进入就绪状态，重新等待cpu调度 &&
void&join(long&millis,int&nanos)&&&&
&&&&等待该线程终止的时间最长为 millis 毫秒 + nanos 纳秒。如果在millis时间内，该线程没有执行完，那么当前线程进入就绪状态，重新等待cpu调度 &
在这个例子中，在主线程中调用thread.join(); 就是将主线程加入到thread子线程后面等待执行。不过有时间限制，为1毫秒。
4、线程的优先级
每个线程执行时都有一个优先级的属性，优先级高的线程可以获得较多的执行机会，而优先级低的线程则获得较少的执行机会。与线程休眠类似，线程的优先级仍然无法保障线程的执行次序。只不过，优先级高的线程获取CPU资源的概率较大，优先级低的也并非没机会执行。
每个线程默认的优先级都与创建它的父线程具有相同的优先级，在默认情况下，main线程具有普通优先级。
Thread类提供了setPriority(int newPriority)和getPriority()方法来设置和返回一个指定线程的优先级，其中setPriority方法的参数是一个整数，范围是1~·0之间，也可以使用Thread类提供的三个静态常量：
MAX_PRIORITY&& =10
MIN_PRIORITY&& =1
NORM_PRIORITY&& =5
从结果可以看到 ，一般情况下，高级线程更显执行完毕。
注意一点：虽然Java提供了10个优先级别，但这些优先级别需要操作系统的支持。不同的操作系统的优先级并不相同，而且也不能很好的和Java的10个优先级别对应。所以我们应该使用MAX_PRIORITY、MIN_PRIORITY和NORM_PRIORITY三个静态常量来设定优先级，这样才能保证程序最好的可移植性。
5、守护线程
守护线程与普通线程写法上基本么啥区别，调用线程对象的方法setDaemon(true)，则可以将其设置为守护线程。
守护线程使用的情况较少，但并非无用，举例来说，JVM的垃圾回收、内存管理等线程都是守护线程。还有就是在做数据库应用时候，使用的数据库连接池，连接池本身也包含着很多后台线程，监控连接个数、超时时间、状态等等。
setDaemon方法的详细说明：
public final void setDaemon(boolean on)将该线程标记为守护线程或用户线程。当正在运行的线程都是守护线程时，Java 虚拟机退出。&&&&
该方法必须在启动线程前调用。 该方法首先调用该线程的 checkAccess 方法，且不带任何参数。这可能抛出 SecurityException（在当前线程中）。&&&
&&&&on - 如果为 true，则将该线程标记为守护线程。&&&&
&&抛出：&&&&
&&&&IllegalThreadStateException - 如果该线程处于活动状态。&&&&
&&&&SecurityException - 如果当前线程无法修改该线程。
执行结果：
从上面的执行结果可以看出：前台线程是保证执行完毕的，后台线程还没有执行完毕就退出了。
实际上：JRE判断程序是否执行结束的标准是所有的前台执线程行完毕了，而不管后台线程的状态，因此，在使用后台县城时候一定要注意这个问题。
守护线程的用途：
守护线程通常用于执行一些后台作业，例如在你的应用程序运行时播放背景音乐，在文字编辑器里做自动语法检查、自动保存等功能。Java的垃圾回收也是一个守护线程。守护线
的好处就是你不需要关心它的结束问题。例如你在你的应用程序运行的时候希望播放背景音乐，如果将这个播放背景音乐的线程设定为非守护线程，那么在用户请求退出的时候，
不仅要退出主线程，还要通知播放背景音乐的线程退出；如果设定为守护线程则不需要了。
6、如何结束一个线程
Thread.stop()、Thread.suspend、Thread.resume、Runtime.runFinalizersOnExit这些终止线程运行的方法已经被废弃了，使用它们是极端不安全的！想要安全有效的结束一个线程，可以使用下面的方法。
1、正常执行完run方法，然后结束掉
2、控制循环条件和判断条件的标识符来结束掉线程
比如说run方法这样写：
只要保证在一定的情况下，run方法能够执行完毕即可。而不是while(true)的无线循环。
3、使用interrupt结束一个线程。
诚然，使用第2中方法的标识符来结束一个线程，是一个不错的方法，但是如果，该线程是处于sleep、wait、join的状态的时候，while循环就不会执行，那么我们的标识符就无用武之地了，当然也不能再通过它来结束处于这3种状态的线程了。
可以使用interrupt这个巧妙的方式结束掉这个线程。
我们看看sleep、wait、join方法的声明：
可以看到，这三者有一个共同点，都抛出了一个InterruptedException的异常。
在什么时候会产生这样一个异常呢？
每个Thread都有一个中断状状态，默认为false。可以通过Thread对象的isInterrupted()方法来判断该线程的中断状态。可以通过Thread对象的interrupt()方法将中断状态设置为true。
当一个线程处于sleep、wait、join这三种状态之一的时候，如果此时他的中断状态为true，那么它就会抛出一个InterruptedException的异常，并将中断状态重新设置为false。
看下面的简单的例子：
测试结果：
可以看到，首先执行第一次while循环，在第一次循环中，睡眠2秒，然后将中断状态设置为true。当进入到第二次循环的时候，中断状态就是第一次设置的true，当它再次进入sleep的时候，马上就抛出了InterruptedException异常，然后被我们捕获了。然后中断状态又被重新自动设置为false了（从最后一条输出可以看出来）。
所以，我们可以使用interrupt方法结束一个线程。具体使用如下：
多测试几次，会发现一般有两种执行结果：
这两种结果恰恰说明了& 只要一个线程的中断状态一旦为true，只要它进入sleep等状态，或者处于sleep状态，立马回抛出InterruptedException异常。
第一种情况，是当主线程从3秒睡眠状态醒来之后，调用了子线程的interrupt方法，此时子线程正处于sleep状态，立马抛出InterruptedException异常。
第一种情况，是当主线程从3秒睡眠状态醒来之后，调用了子线程的interrupt方法，此时子线程还没有处于sleep状态。然后再第3次while循环的时候，在此进入sleep状态，立马抛出InterruptedException异常。
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：48427次
积分：1767
积分：1767
排名：第17560名
原创：101篇
转载：175篇
译文：11篇
(2)(14)(1)(3)(18)(12)(16)(13)(15)(7)(7)(12)(22)(53)(1)(5)(8)(3)(1)(20)(10)(8)(12)(10)(10)(2)查看: 222|回复: 6
求一个类_线程池监控线程是否运行完的例程
阅读权限70
在线时间 小时
结帖率： (9/12)
求一个的类_线程池监控线程是否运行完的例程，不是类_线程池1，
.支持库 spec
.局部变量 i, 整数型
.局部变量 , 类_线程池
多线程.启动 (3, &工作, )
.计次循环首 (取数组成员数 (集_政策信息), i)
& & 多线程.加入工作 (i)
.计次循环尾 ()
怎样判断线程是否运行完，只有运行完才能执行下一步操作。
回答提醒：如果本帖被关闭无法回复，您有更好的答案帮助楼主解决，请发表至
可获得加分喔。友情提醒：本版被采纳的主题可在
帖子申请荣誉值，获得 1点 荣誉值,荣誉值可兑换终身vip用户组哦。快捷通道： →
阅读权限165
在线时间 小时
签到天数: 3 天结帖率： (3/3)
等待线程()
您可以选择打赏方式支持他
阅读权限50
在线时间 小时
签到天数: 3 天
不懂线程池就不要胡说,
线程池里的线程是预先启动好的,没有运行完毕一说,
只有主动释放线程,
而且线程池是个高效而又复杂的过程
您可以选择打赏方式支持他
阅读权限70
在线时间 小时
结帖率： (9/12)
不懂线程池就不要胡说,
线程池里的线程是预先启动好的,没有运行完毕一说,
只有主动释放线程,
这里不是你装逼的地方
您可以选择打赏方式支持他
阅读权限50
在线时间 小时
签到天数: 3 天
这里不是你装逼的地方
你这人的态度好差,真是狗咬吕洞宾不识好人心
您可以选择打赏方式支持他
阅读权限70
在线时间 小时
结帖率： (9/12)
你这人的态度好差,真是狗咬吕洞宾不识好人心
看清楚你是怎么说话的，就算我不懂我还不能问了？明眼人都明白我问的什么意思。
您可以选择打赏方式支持他
阅读权限50
在线时间 小时
签到天数: 3 天
看清楚你是怎么说话的，就算我不懂我还不能问了？明眼人都明白我问的什么意思。
我什么时候说你不能问了,我只是说你说的不对而已,我这是指出你不对的地方
就这样你都能骂人,真是服了
您可以选择打赏方式支持他
精易论坛 - 有你更精彩 /1
还在为某个APP无法抓取数据而烦恼？热门的APP快手，最新版登录数据无法抓取问题?
课程提供大量的技术和方法解决某些app无法抓取数据的问题。
还在为填表的繁琐而烦闷不已？还在为封包的速度和技巧无限纠结？
在post课程将学到QQ授权登录各类网页、QQ授权登录各类APP。JS跟踪、调试、解析等等。
海量实例，绝对物超所值！
拒绝任何人以任何形式在本论坛发表与中华人民共和国法律相抵触的言论，本站内容均为会员发表，并不代表精易立场!
揭阳精易科技有限公司申明:我公司所有的培训课程版权归精易所有，任何人以任何方式翻录、盗版、破解本站培训课程，我们必将通过法律途径解决！
公司简介：揭阳市揭东区精易科技有限公司致力于易语言教学培训/易语言学习交流社区的建设与软件开发，多年来为中小企业编写过许许多多各式软件，并把多年积累的开发经验逐步录制成视频课程供学员学习，让学员全面系统化学习易语言编程，少走弯路，减少对相关技术的研究与摸索时间，从而加快了学习进度！
Powered by请教大虾们，我要在中监控应用中的线程是否在运行，请问该如何去做？谢谢各位不吝赐教。
--------------------------------------
你可以单独起个监控线程，监控线程与被监控线程之间通过发送心跳来确认是否正常运行[Java并发编程]-线程的六种状态及其状态转换
1.线程自身信息
线程运行的过程会产生很多信息，这些信息都保存在Thread类中的成员变量里面，常见的有：
a.线程的ID是唯一标识getId()
b.线程的名称：getName()，如果不设置线程名称默认为&Thread-xx&
c.线程的优先级：getPriority，线程优先级从1-10,其中数字越大表示优先级别越高，同时获得JVM调度执行的可能性越大，JDK内置了三种常见的状态：
//最小优先级
public final static int MIN_PRIORITY = 1;
//一般优先级
public final static int NORM_PRIORITY = 5;
//最大优先级
public final static int MAX_PRIORITY = 10;
一般不推荐设置线程的优先级，如果进行设置了非法的优先级程序就会出现IllegalArgumentException异常。
2.线程的几个状态
1.线程有六种状态
public enum State {
//线程刚创建
//在JVM中正在运行的线程
//线程处于阻塞状态，等待监视锁，可以重新进行同步代码块中执行
//等待状态
//调用sleep() join() wait()方法可能导致线程处于等待状态
TIMED_WAITING,
//线程执行完毕，已经退出
TERMINATED;
上面六种状态图如下：
2.线程状态的解释
1.当线程继承Thread或者实现了Runnable创建了线程对象后，当new线程对象过后线程就进入了初始的状态。
2.当线程对象调用了start()方法的时候，线程启动进入可运行的状态。
3.线程进入可运行状态后，如果逻辑完成那么线程将会终结，如果没有执行完毕中间JVM分配时间片用完，将进入可运行状态，一旦线程被JVM选中则立即执行。
4.运行状态的情况比较复杂
第一：线程如果执行run() main()方法结束后，完成逻辑，线程就进入Terminated
第二：当线程调用sleep()或者join()方法就会进入Blocked状态，但是要注意的是阻塞的线程是不释放当前所占有的资源，当sleep()结束或者join()等待其他线程来到，当前线程则进入Runnable状态等待JVM分配资源。
第三：当线程进入Runnable状态，但是还没有开始运行的时候，此时发现需要的资源处于同步状态synchronized，这个时候线程将会进入Time waiting,JVM会使用队列对这些线程进行控制，既先进行Time waiting的线程会先得到JVM资源进行执行进入Waiting
第四：如果处于Runnable的线程调用yield()让出JVM资源，那么就会进入New状态和其他New状态线程进行竞争重新进入Runnable
第五：如果当前线程调用wait()方法，则当前线程进入Time waiting但是这个时候当前线程会释放所占有的JVM资源，进入这个状态过后是不能自动唤醒的，必须调用notify()或者notifyAll()方法，线程进入Waiting。
3.案例解释
案例：用案例解释线程的六种运行状态,其中Pig类实现Runnable接口，逻辑是打印当前运行的线程信息，
每隔一秒打印一次。在Main方法中启动十个Pig线程设置相应的线程优先级别，并且将初始的线程状态
保存到线程状态数组中，在运行的过程判断当前线程状态和初始状态是否相同，如果不同则打印当前线
程的信息保存到日志文件中。
class Pig implements Runnable {
public void run() {
for (int i = 0; i & 10; i++) {
//线程进行休眠一秒
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
//打印当前执行线程信息
System.out.println(ThreadName :
+ Thread.currentThread().getName());
public class App {
public static void main(String[] args) throws Exception {
// 创建现成数组
Thread[] taskArr = new Thread[10];
// 线程状态数组
Thread.State[] threadStates = new Thread.State[10];
// 设置线程的状态
for (int i = 0; i & 10; i++) {
taskArr[i] = new Thread(new Pig());
// 分别设置状态
if ((i % 3) == 0) {
taskArr[i].setPriority(Thread.NORM_PRIORITY);
} else if ((i % 3) == 1) {
taskArr[i].setPriority(Thread.MIN_PRIORITY);
} else if ((i % 3) == 2) {
taskArr[i].setPriority(Thread.MAX_PRIORITY);
// 将线程信息写入到文件中便于分析
FileWriter fWriter = new FileWriter(.\log.txt);
PrintWriter pWriter = new PrintWriter(fWriter);
// 循环遍历获取线程的信息
for (int i = 0; i & 10; i++) {
pWriter.println(线程
状态： + taskArr[i].getState());
// 将当前线程状态保存到状态数组中
threadStates[i] = taskArr[i].getState();
// 启动线程
for (int i = 0; i & 10; i++) {
taskArr[i].start();
// 在运行过程中如果线程的状态和初始状态不一样就将状态变化过程写入到文件中
boolean finish =
while (!finish) {
for (int i = 0; i & 10; i++) {
// 线程状态发生变化
if (taskArr[i].getState() != threadStates[i]) {
// 打印线程当前信息
printThreadMsg(pWriter, taskArr[i], threadStates[i]);
// 将当前线程状态保存到线程状态数组中
threadStates[i] = taskArr[i].getState();
for (int i = 0; i & 10; i++) {
finish = finish && (taskArr[i].getState() == State.TERMINATED);
* 打印当前线程的信息
* @param pWriter
* @param thread
* @param state
private static void printThreadMsg(PrintWriter pWriter, Thread thread, State state) {
pWriter.println(*********************************************************);
pWriter.println(线程ID:
+ thread.getId() +
线程名称: + thread.getName());
pWriter.println(线程优先级： + thread.getPriority());
pWriter.println(线程过去状态： + state);
pWriter.println(线程当前状态： + thread.getState());
pWriter.println(*********************************************************);
部分执行结果如下：
分析上面的部分执行结果就可以看出当Pig线程进行休眠的时候，就会导致其他线程状态的变换，其中过去状态和当前状态可以明显的反应出线程状态切换。
(window.slotbydup=window.slotbydup || []).push({
id: '2467140',
container: s,
size: '1000,90',
display: 'inlay-fix'
(window.slotbydup=window.slotbydup || []).push({
id: '2467141',
container: s,
size: '1000,90',
display: 'inlay-fix'
(window.slotbydup=window.slotbydup || []).push({
id: '2467142',
container: s,
size: '1000,90',
display: 'inlay-fix'
(window.slotbydup=window.slotbydup || []).push({
id: '2467143',
container: s,
size: '1000,90',
display: 'inlay-fix'
(window.slotbydup=window.slotbydup || []).push({
id: '2467148',
container: s,
size: '1000,90',
display: 'inlay-fix'