java中yieldsleep以及wait的区别.docx
《java中yieldsleep以及wait的区别.docx》由会员分享，可在线阅读，更多相关《java中yieldsleep以及wait的区别.docx（18页珍藏版）》请在冰点文库上搜索。
java中yieldsleep以及wait的区别
往往混淆了这三个函数的使用。
从操作系统的角度讲，os会维护一个readyqueue（就绪的线程队列）。
并且在某一时刻cpu只为readyqueue中位于队列头部的线程服务。
但是当前正在被服务的线程可能觉得cpu的服务质量不够好，于是提前退出，这就是yield。
或者当前正在被服务的线程需要睡一会，醒来后继续被服务，这就是sleep。
?
?
sleep方法不推荐使用，可用wait。
线程退出最好自己实现，在运行状态中一直检验一个状态，如果这个状态为真，就一直运行，如果外界更改了这个状态变量，那么线程就停止运行。
sleep（）使当前线程进入停滞状态，所以执行sleep（）的线程在指定的时间内肯定不会执行；yield（）只是使当前线程重新回到可执行状态，所以执行yield（）的线程有可能在进入到可执行状态后马上又被执行。
sleep（）可使优先级低的线程得到执行的机会，当然也可以让同优先级和高优先级的线程有执行的机会；yield（）只能使同优先级的线程有执行的机会。
当调用wait（）后，线程会释放掉它所占有的“锁标志”，从而使线程所在对象中的其它synchronized数据可被别的线程使用。
waite（）和notify（）因为会对对象的“锁标志”进行操作，所以它们必须在synchronized函数或synchronized block中进行调用。
如果在non-synchronized函数或non-synchronized block中进行调用，虽然能编译通过，但在运行时会发生IllegalMonitorStateException的异常。
彻底明白多线程通信机制：
?
?
线程间的通信
1.?
?
线程的几种状态
线程有四种状态，任何一个线程肯定处于这四种状态中的一种：
1）?
?
产生（New）：
线程对象已经产生，但尚未被启动，所以无法执行。
如通过new产生了一个线程对象后没对它调用start（）函数之前。
2）?
?
可执行（Runnable）：
每个支持多线程的系统都有一个排程器，排程器会从线程池中选择一个线程并启动它。
当一个线程处于可执行状态时，表示它可能正处于线程池中等待排排程器启动它；也可能它已正在执行。
如执行了一个线程对象的start（）方法后，线程就处于可执行状态，但显而易见的是此时线程不一定正在执行中。
3）?
?
死亡（Dead）：
当一个线程正常结束，它便处于死亡状态。
如一个线程的run（）函数执行完毕后线程就进入死亡状态。
4）?
?
停滞（Blocked）：
当一个线程处于停滞状态时，系统排程器就会忽略它，不对它进行排程。
当处于停滞状态的线程重新回到可执行状态时，它有可能重新执行。
如通过对一个线程调用wait（）函数后，线程就进入停滞状态，只有当两次对该线程调用notify或notifyAll后它才能两次回到可执行状态。
2.?
?
class Thread下的常用函数函数
2.1?
?
suspend（）、resume（）
1）?
?
通过suspend（）函数，可使线程进入停滞状态。
通过suspend（）使线程进入停滞状态后，除非收到resume（）消息，否则该线程不会变回可执行状态。
2）?
?
当调用suspend（）函数后，线程不会释放它的“锁标志”。
例11：
?
?
classTestThreadMethodextendsThread{
?
?
?
?
?
?
publicstaticintshareVar=0;
?
?
?
?
?
?
publicTestThreadMethod（Stringname）{
?
?
?
?
?
?
?
?
super（name）;
?
?
?
?
?
?
}
?
?
?
?
?
?
publicsynchronizedvoidrun（）{
?
?
?
?
?
?
?
?
if（shareVar==0）{
?
?
?
?
?
?
?
?
?
?
for（inti=0;i<5;i++）{
?
?
?
?
?
?
?
?
?
?
?
?
?
?
shareVar++;
?
?
?
?
?
?
?
?
?
?
?
?
?
?
if（shareVar==5）{
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
this.suspend（）; //
（1）
?
?
?
?
?
?
?
?
?
?
?
?
?
?
}
?
?
?
?
?
?
?
?
?
?
}
?
?
?
?
?
?
?
?
}
?
?
?
?
?
?
?
?
else{
?
?
?
?
?
?
?
?
?
?
this.resume（）; //
（2）
?
?
?
?
?
?
?
?
}
?
?
?
?
?
?
}
?
?
}
?
?
publicclassTestThread{
?
?
?
?
?
?
publicstaticvoidmain（String[]args）{
?
?
?
?
?
?
?
?
TestThreadMethodt1=newTestThreadMethod（"t1"）;
TestThreadMethodt2=newTestThreadMethod（"t2"）;
t1.start（）; //（5）
?
?
?
?
?
?
?
?
//t1.start（）; //（3）
?
?
?
?
?
?
?
?
t2.start（）; //（4）
?
?
?
?
?
?
}
}
运行结果为：
t2shareVar=5
i.?
?
当代码（5）的t1所产生的线程运行到代码
（1）处时，该线程进入停滞状态。
然后排程器从线程池中唤起代码（4）的t2所产生的线程，此时shareVar值不为0，所以执行else中的语句。
ii.?
?
也许你会问，那执行代码
（2）后为什么不会使t1进入可执行状态呢？
正如前面所说，t1和t2是两个不同对象的线程，而代码
（1）和
（2）都只对当前对象进行操作，所以t1所产生的线程执行代码
（1）的结果是对象t1的当前线程进入停滞状态；而t2所产生的线程执行代码
（2）的结果是把对象t2中的所有处于停滞状态的线程调回到可执行状态。
iii.?
?
那现在把代码（4）注释掉，并去掉代码（3）的注释，是不是就能使t1重新回到可执行状态呢？
运行结果是什么也不输出。
为什么会这样呢？
也许你会认为，当代码（5）所产生的线程执行到代码
（1）时，它进入停滞状态；而代码（3）所产生的线程和代码（5）所产生的线程是属于同一个对象的，那么就当代码（3）所产生的线程执行到代码
（2）时，就可使代码（5）所产生的线程执行回到可执行状态。
但是要清楚，suspend（）函数只是让当前线程进入停滞状态，但并不释放当前线程所获得的“锁标志”。
所以当代码（5）所产生的线程进入停滞状态时，代码（3）所产生的线程仍不能启动，因为当前对象的“锁标志”仍被代码（5）所产生的线程占有。
2.2?
?
?
?
sleep（）
1）?
?
sleep（）函数有一个参数，通过参数可使线程在指定的时间内进入停滞状态，当指定的时间过后，线程则自动进入可执行状态。
2）?
?
当调用sleep（）函数后，线程不会释放它的“锁标志”。
例12：
?
?
classTestThreadMethodextendsThread{
?
?
?
?
?
?
classTestThreadMethodextendsThread{
?
?
?
?
?
?
publicstaticintshareVar=0;
?
?
?
?
?
?
publicTestThreadMethod（Stringname）{
?
?
?
?
?
?
?
?
super（name）;
?
?
?
?
?
?
}
?
?
?
?
?
?
publicsynchronizedvoidrun（）{
?
?
?
?
?
?
?
?
for（inti=0;i<3;i++）{
?
?
?
?
?
?
?
?
?
?
try{
?
?
?
?
?
?
?
?
?
?
?
?
?
?
Thread.sleep（100）; //（4）
?
?
?
?
?
?
?
?
?
?
}
?
?
?
?
?
?
?
?
?
?
catch（InterruptedExceptione）{
?
?
?
?
?
?
?
?
?
?
}
?
?
?
?
?
?
?
?
}
?
?
?
?
?
?
}
?
?
}
?
?
publicclassTestThread{
?
?
?
?
?
?
publicstaticvoidmain（String[]args）{
?
?
?
?
?
?
?
?
TestThreadMethodt1=newTestThreadMethod（"t1"）;
?
?
?
?
?
?
?
?
TestThreadMethodt2=newTestThreadMethod（"t2"）;
?
?
?
?
?
?
?
?
t1.start（）;
（1）
?
?
?
?
?
?
?
?
t1.start（）;
（2）
?
?
?
?
?
?
?
?
//t2.start（）; （3）
?
?
?
?
?
?
}
}
运行结果为：
t1:
0
t1:
1
t1:
2
t1:
0
t1:
1由结果可证明，虽然在run（）中执行了sleep（），但是它不会释放对象的“锁标志”，所以除非代码
（1）的线程执行完run（）函数并释放对象的“锁标志”，否则代码
（2）的线程永远不会执行。
?
?
?
?
?
?
?
?
?
?
如果把代码
（2）注释掉，并去掉代码（3）的注释，结果将变为：
t1:
0
t2:
0
t1:
1
t2:
1
t1:
2
t2:
2
由于t1和t2是两个对象的线程，所以当线程t1通过sleep（）进入停滞时，排程器会从线程池中调用其它的可执行线程，从而t2线程被启动。
?
?
?
?
?
?
?
?
?
?
例13：
?
?
classTestThreadMethodextendsThread{
?
?
?
?
?
?
publicstaticintshareVar=0;
?
?
?
?
?
?
publicTestThreadMethod（Stringname）{
?
?
?
?
?
?
?
?
super（name）;
?
?
?
?
?
?
}
?
?
?
?
?
?
publicsynchronizedvoidrun（）{
?
?
?
?
?
?
?
?
for（inti=0;i<5;i++）{
?
?
?
?
?
?
?
?
?
?
try{
?
?
?
?
?
?
?
?
?
?
?
?
?
?
if（Thread.currentThread（）.getName（）.equals（"t1"））
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
Thread.sleep（200）;
?
?
?
?
?
?
?
?
?
?
?
?
?
?
else
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
Thread.sleep（100）;
?
?
?
?
?
?
?
?
?
?
}
?
?
?
?
?
?
?
?
?
?
catch（InterruptedExceptione）{
?
?
?
?
?
?
?
?
?
?
}
?
?
?
?
?
?
?
?
}
?
?
?
?
?
?
}
?
?
}
?
?
publicclassTestThread{
?
?
?
?
?
?
publicstaticvoidmain（String[]args）{
?
?
?
?
?
?
?
?
TestThreadMethodt1=newTestThreadMethod（"t1"）;
?
?
?
?
?
?
?
?
TestThreadMethodt2=newTestThreadMethod（"t2"）;
?
?
?
?
?
?
?
?
t1.start（）;
?
?
?
?
?
?
?
?
//t1.start（）;
?
?
?
?
?
?
?
?
t2.start（）;
?
?
?
?
?
?
}
?
?
}
运行结果为：
t1:
0
t2:
0
t2:
1
t1:
1
t2:
2
t2:
3
t1:
2
t2:
4
t1:
3
t1:
4
由于线程t1调用了sleep（200），而线程t2调用了sleep（100），所以线程t2处于停滞状态的时间是线程t1的一半，从从结果反映出来的就是线程t2打印两倍次线程t1才打印一次。
2.3?
?
yield（）
1）?
?
通过yield（）函数，可使线程进入可执行状态，排程器从可执行状态的线程中重新进行排程。
所以调用了yield（）的函数也有可能马上被执行。
2）?
?
当调用yield（）函数后，线程不会释放它的“锁标志”。
例14：
?
?
classTestThreadMethodextendsThread{
?
?
?
?
?
?
publicstaticintshareVar=0;
?
?
?
?
?
?
publicTestThreadMethod（Stringname）{
?
?
?
?
?
?
?
?
super（name）;
?
?
?
?
?
?
}
?
?
?
?
?
?
publicsynchronizedvoidrun（）{
?
?
?
?
?
?
?
?
for（inti=0;i<4;i++）{
?
?
?
?
?
?
?
?
?
?
Thread.yield（）;
?
?
?
?
?
?
?
?
}
?
?
?
?
?
?
}
?
?
}
?
?
publicclassTestThread{
?
?
?
?
?
?
publicstaticvoidmain（String[]args）{
?
?
?
?
?
?
?
?
TestThreadMethodt1=newTestThreadMethod（"t1"）;
?
?
?
?
?
?
?
?
TestThreadMethodt2=newTestThreadMethod（"t2"）;
?
?
?
?
?
?
?
?
t1.start（）;
?
?
?
?
?
?
?
?
t1.start（）; //
（1）
?
?
?
?
?
?
?
?
//t2.start（）;
（2）
?
?
?
?
?
?
}
}
运行结果为：
t1:
0
t1:
1
t1:
2
t1:
3
t1:
0
t1:
1
t1:
2
t1:
3
从结果可知调用yield（）时并不会释放对象的“锁标志”。
?
?
?
?
?
?
?
?
?
?
如果把代码
（1）注释掉，并去掉代码
（2）的注释，结果为：
t1:
0
t1:
1
t2:
0
t1:
2
t2:
1
t1:
3
t2:
2
t2:
3
从结果可知，虽然t1线程调用了yield（），但它马上又被执行了。
2.4?
?
sleep（）和yield（）的区别
1）?
?
sleep（）使当前线程进入停滞状态，所以执行sleep（）的线程在指定的时间内肯定不会执行；yield（）只是使当前线程重新回到可执行状态，所以执行yield（）的线程有可能在进入到可执行状态后马上又被执行。
2）?
?
sleep（）可使优先级低的线程得到执行的机会，当然也可以让同优先级和高优先级的线程有执行的机会；yield（）只能使同优先级的线程有执行的机会。
例15：
?
?
classTestThreadMethodextendsThread{
?
?
?
?
?
?
publicstaticintshareVar=0;
?
?
?
?
?
?
publicTestThreadMethod（Stringname）{
?
?
?
?
?
?
?
?
super（name）;
?
?
?
?
?
?
}
?
?
?
?
?
?
publicvoidrun（）{
?
?
?
?
?
?
?
?
for（inti=0;i<4;i++）{
?
?
?
?
?
?
?
?
?
?
//Thread.yield（）;
（1）
?
?
?
?
?
?
?
?
?
?
/*
（2）*/
?
?
?
?
?
?
?
?
?
?
try{
?
?
?
?
?
?
?
?
?
?
?
?
?
?
Thread.sleep（3000）;
?
?
?
?
?
?
?
?
?
?
}
?
?
?
?
?
?
?
?
?
?
catch（InterruptedExceptione）{
?
?
?
?
?
?
?
?
?
?
}
?
?
?
?
?
?
?
?
}
?
?
?
?
?
?
}
?
?
}
?
?
publicclassTestThread{
?
?
?
?
?
?
publicstaticvoidmain（String[]args）{
?
?
?
?
?
?
?
?
TestThreadMethodt1=newTestThreadMethod（"t1"）;
?
?
?
?
?
?
?
?
TestThreadMethodt2=newTestThreadMethod（"t2"）;
?
?
?
?
?
?
?
?
t1.setPriority（Thread.MAX_PRIORITY）;
?
?
?
?
?
?
?
?
t2.setPriority（Thread.MIN_PRIORITY）;
?
?
?
?
?
?
?
?
t1.start（）;
?
?
?
?
?
?
?
?
t2.start（）;
?
?
?
?
?
?
}
}
运行结果为：
t1:
0
t1:
1
t2:
0
t1:
2
t2:
1
t1:
3
t2:
2
t2:
3
由结果可见，通过sleep（）可使优先级较低的线程有执行的机会。
注释掉代码
（2），并去掉代码
（1）的注释，结果为：
t1:
0
t1:
1
t1:
2
t1:
3
t2:
0
t2:
1
t2:
2
t2:
3
可见，调用yield（），不同优先级的线程永远不会得到执行机会。
2.5?
?
join（）
使调用join（）的线程执行完毕后才能执行其它线程，在一定意义上，它可以实现同步的功能。
例16：
?
?
classTestThreadMethodextendsThread{
?
?
?
?
?
?
publicstaticintshareVar=0;
?
?
?
?
?
?
publicTestThreadMethod（Stringname）{
?
?
?
?
?
?
?
?
super（name）;
?
?
?
?
?
?
}
?
?
?
?
?
?
publicvoidrun（）{
?
?
?
?
?
?
?
?
for（inti=0;i<4;i++）{
?
?
?
?
?
?
?
?
?
?
try{
?
?
?
?
?
?
?
?
?
?
?
?
?
?
Thread.sleep（3000）;
?
?
?
?
?
?
?
?
?
?
}
?
?
?
?
?
?
?
?
?
?
catch（InterruptedExceptione）{
?
?
?
?
?
?
?
?
?
?
}
?
?
?
?
?
?
?
?
}
?
?
?
?
?
?
}
?
?
}
?
?
publicclassTestThread{
?
?
?
?
?
?
publicstaticvoidmain（String[]args）{
?
?
?
?
?
?
?
?
TestThreadMethodt1=newTestThreadMethod（"t1"）;
?
?
?
?
?
?
?
?
t1.start（）;
?
?
?
?
?
?
?
?
try{
?
?
?
?
?
?
?
?
?
?
t1.join（）;
?
?
?
?
?
?
?
?
}
?
?
?
?
?
?
?
?
catch（InterruptedExceptione）{}
?
?
?
?
?
?
?
?
t1.start（）;
?
?
?
?
?
?
}
}
运行结果为：
0
1
2
3
0
1
2
33.class Object下常用的线程函数
3.1wait（）、notify（）和notifyAll（）
1）wait（）函数有两种形式：
第一种形式接受一个毫秒值，用于在指定时间长度内暂停线程，使线程进入停滞状态。
第二种形式为不带参数，代表waite（）在notify（）或notifyAll（）之前会持续停滞。
2）当对一个对象执行notify（）时，会从线程等待池中移走该任意一个线程，并把它放到锁标志等待池中；当对一个对象执行notifyAll（）时，会从线程等待池中移走所有该对象的所有线程，并把它们放到锁标志等待池中。
3）当调用wait（）后，线程会释放掉它所占有的“锁标志”，从而使线程所在对象中的其它synchronized数据可被别的线程使用。
例17：
下面，我们将对例11中的例子进行修改
classTestThreadMethodextendsThread{
publicstaticintshareVar=0;
publicTestThreadMethod（Stringname）{
super（name）;
}
publicsynchronizedvoidrun（）{
if（shareVar==0）{
for（inti=0;i<10;i++）{
shareVar++;
if（shareVar==5）{
try{
this.wait（）; //（4）
}
catch（InterruptedExceptione）{}
}
}
}
if（shareVar!
=0）{
this.notify（）; //（5）
}
}
}
publicclassTestThread{
publicstaticvoidmain（String[]args）{
TestThreadMethodt1=newTestThreadMethod（"t1"）;
TestThreadMethodt2=newTestThreadMethod（"t2"）;
t1.start（）; //
（1）
//t1.start（）;
（2）
t2.start（）; //（3）
}
}
运行结果为：
t2shareVar=5
因为t1和t2是两个不同对象，所以线程t2调用代码（5）不能唤起线程t1。
如果去掉代码
（2）的注释，并注释掉代码（3），结果为：
t1shareVar=5
t1shareVar=10
这是因为，当代码
（1）的线程执行到代码（4）时，它进入停滞状态，并释放对象的锁状态。
接着，代码
（2）的线程执行run（），由于此时shareVar值为5，所以执行打印语句并调用代码（5）使代码
（1）的线程进入可执行状态，然后代码
（2）的线程结束。
当代码
（1）的线程重新执行后，它接着执行for（）循环一直到shareVar=10，然后打印shareVar。
3.2wait（）、notify（）和synchronized
waite（）和notify（）因为会对对象的“锁标志”进行操作，所以它们必须在synchronized函数或synchronized block中进行调用。
如果在non-synchronized函数或non-synchronized block中进行调用，虽然能编译通过，但在运行时会发生IllegalMonitorStateException的异常。
例18：
classTestThreadMethodextendsThread{
publicintshareVar=0;
publicTestThreadMethod（Stringname）{
super（name）;
newNotifier（this）;
}
publicsynchronizedvoidrun（）{
if（shareVar==0）{
for（inti=0;i<5;i++）{
shareVar++;
try{
this.wait（）;
}
catch（InterruptedExceptione）{}
}
}
}
}
classNotifierextendsThread{
privateTestThreadMethodttm;
Notifier（TestThreadMethodt）{
ttm=t;
start（）;
}
publicvoidrun（）{
while（true）{
try{
sleep（2000）;
}
catch（InterruptedExceptione）{}
/*1要同步的不是当前对象的做法*/
synchronized（ttm）{
ttm.notify（）;
}
}
}
}
publicclassTestThread{
publicstaticvoidmain（String[]args）{
TestThreadMethodt1=newTestThreadMethod（"t1"）;
t1.start（）;
}
运行结果为：
i=1
wait......
notify......
i=2
wait......
notify......
i=3
wait......
notify......
i=4
wait......
notify......
i=5
wait......
notify......
4.wait（）、notify（）、notifyAll（）和suspend（）、resume（）、sleep（）的讨论
4.1这两组函数的区别
1）wait（）使当前线程进入停滞状态时，还会释放当前线程所占有的“锁标志”，从而使线程对象中的synchronized资源可被对象中别的线程使用；而suspend（）和sleep（）使当前线程进入停滞状态时不会释放当前线程所占有的“锁标志”。
2）前一组函数必须在synchronized函数或synchronized block中调用，否则在运行时会产生错误；而后一组函数可以non-synchronized函数和synchronized block中调用。
升级会员 