java之yield(),sleep(),wait()区别详解

1、sleep()

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

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

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

 

2、join()

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

 

3、yield()

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

 

4、wait()和notify()、notifyAll()

 

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

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

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

注意 这三个方法都是java.lang.Object的方法。

 

 

二、run和start()

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

 

三、关键字synchronized

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

 

 

四、wait()和notify(),notifyAll()是Object类的方法，sleep()和yield()是Thread类的方法。

(1)、常用的wait方法有wait()和wait(long timeout);

void wait() 在其他线程调用此对象的 notify() 方法或者 notifyAll()方法前，导致当前线程等待。

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

wait()后，线程会释放掉它所占有的“锁标志”，从而使线程所在对象中的其他shnchronized数据可被别的线程使用。

 

wait()h和notify()因为会对对象的“锁标志”进行操作，所以他们必需在Synchronized函数或者 synchronized block 中进行调用。如果在non-synchronized 函数或 non-synchronized block 中进行调用，虽然能编译通过，但在运行时会发生IllegalMonitorStateException的异常。。

 

(2)、Thread.sleep(long millis)必须带有一个时间参数。

sleep(long)使当前线程进入停滞状态，所以执行sleep()的线程在指定的时间内肯定不会被执行；

sleep(long)可使优先级低的线程得到执行的机会，当然也可以让同优先级的线程有执行的机会；

sleep(long)是不会释放锁标志的。

 

(3)、yield()没有参数

sleep 方法使当前运行中的线程睡眠一段时间，进入不可以运行状态，这段时间的长短是由程序设定的，yield方法使当前线程让出CPU占有权，但让出的时间是不可设定的。

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

实际上，yield()方法对应了如下操作；先检测当前是否有相同优先级的线程处于同可运行状态，如有，则把CPU的占有权交给次线程，否则继续运行原来的线程，所以yield()方法称为“退让”，它把运行机会让给了同等级的其他线程。

 

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

 

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

 

===================================================================================================

搞懂这两个的用法之前，请你务必搞懂线程同步的道理，否则，下面这一大篇你应该是看不懂的。

wait()和notify()一系列的方法，是属于对象的，不是属于线程的。它们用在线程同步时，synchronized语句块中。

我们都知道，在synchronized语句块中，同一个对象，一个线程在执行完这一块代码之前，另一个线程，如果传进来的是同一个object，是不能进入这个语句块的。也就是说，同一个对象

是不能同时被两个线程用来进入synchronized中的。这就是线程同步。

废话不多说，先用通俗一点的语言来解释一下wait()和notify()：

wait()意思是说，我等会儿再用这把锁，CPU也让给你们，我先休息一会儿！

notify()意思是说，我用完了，你们谁用？

 

也就是说，wait()会让出对象锁，同时，当前线程休眠，等待被唤醒，如果不被唤醒，就一直等在那儿。

notify()并不会让当前线程休眠，但会唤醒休眠的线程。

先看第一个例子！

 

public class ThreadF {

 

public static void main(String[] args) {

final Object object = new Object();

Thread t1 = new Thread() {

public void run() {

synchronized (object) {

System.out.println("T1 start!");

try {

object.wait();

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println("T1 end!");

}

}

};

Thread t2 = new Thread() {

public void run() {

synchronized (object) {

System.out.println("T2 start!");

object.notify();

System.out.println("T2 end!");

}

}

};

 

t1.start();

t2.start();

 

}

 

}

这第一个例子很简单，写了两个线程（分别是两个类，两个run方法）。

两个run方法之间没有关系，但是，他们都用了同一个object!

仔细看，T1里面主要写了个wait()，而T2里面主要写了个notify()。

我们看到执行结果是：

T1 start!

T2 start!

T2 end!

T1 end!

流程可以这样解释：

T1启动，让出锁，让出CPU，T2获得CPU，启动，唤醒使用了object的休眠的线程，T1被唤醒后等待启动，T2继续执行，T2执行完，T1获得CPU后继续执行。

值得一提的是，再强调一遍：

wait会让出CPU而notify不会，notify重在于通知使用object的对象“我用完了！”，wait重在通知其它同用一个object的线程“我暂时不用了”并且让出CPUT。

所以说，看上面的顺序，

T2 start!

T2 end!

是连续的，说明它并没有因调用了notify而暂停！

 

 

那么，如

 

果两个线程都写wait没有线程写notify会有什么现象呢？试一下就知道了。

结果是，

T1 start!

T2 start!

然后就是一直等待!

道理很显然，T1先启动，然后wait了，T2获得了锁和CPU，在没有其它线程与它竞争的情况下，T2执行了，然后也wait了。

在这里，两个线程都在等待，没有其它线程将它们notify，所以结果就是无休止地等下去！

至少说明了一点，wait后如果没有其它线程将它notify，是绝不可能重新启动的。不可能因为目前没有线程占用CPU，某一个正在等待的线程就自动重启。

 

下面，我再把它改一下，写四个线程，分别是

T1 wait()

T2 notify()

T3 notify()

T4 wait()

 

 

public class ThreadF {

 

public static void main(String[] args) {

final Object object = new Object();

Thread t1 = new Thread() {

public void run() {

synchronized (object) {

System.out.println("T1 start!");

try {

object.wait();

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println("T1 end!");

}

}

};

Thread t2 = new Thread() {

public void run() {

synchronized (object) {

System.out.println("T2 start!");

object.notify();

System.out.println("T2 end!");

}

}

};

Thread t3 = new Thread() {

public void run() {

synchronized (object) {

System.out.println("T3 start!");

object.notify();

System.out.println("T3 end!");

}

}

};

Thread t4 = new Thread() {

public void run() {

synchronized (object) {

System.out.println("T4 start!");

try {

object.wait();

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println("T4 end!");

}

}

};

t1.start();

t2.start();

t3.start();

t4.start();

}

 

}

 

首先，大家知道，线程启动的顺序，和代码的先后顺序，理论上是没有关系的！

比如我这儿写的是按T1-T2-T3-T4的先后顺序先后start()，但实际上谁先启动，是有一定几率的。

执行上面代码，有两种结果：

一种是刚好wait两次，notify两次，notify在wait之后执行，刚好执行完。

另一种是，也是刚好wait两次，notify两次，但是，notify在wait之前执行，于是，至少会有一个线程由于后面没有线程将它notify而无休止

 

地等待下去！

我摘选了两种情况的输出结果，仅供参考：

1、可以执行结束的情况：

T1 start!

T2 start!

T2 end!

T1 end!

T4 start!

T3 start!

T3 end!

T4 end!

执行流程是：

T1启动，wait,T2获得锁和CPU，T2宣布锁用完了其它线程可以用了，然后继续执行，T2执行完，T1被刚才T2唤醒后，等待T2执行完后，抢到了CPU，T1执行，

T1执行完，T4获得CPU，启动，wait,T3获得了锁和CPU，执行，宣布锁用完了，其它线程可以用了，然后继续执行，T3执行完，已经被唤醒并且等待已久的T4

得到CPU，执行。

2、不能执行结束，有线程由于没有其它线程唤醒，一直在等待中：

T1 start!

T2 start!

T2 end!

T1 end!

T3 start!

T3 end!

T4 start!

执行流程：

T1启动，wait，让出CPU和锁，T2得以启动。T2启动，并唤醒一个线程，自己继续执行。被唤醒的线程，也就是T1等待启动机会。

T2执行完，T1抢到了CPU，执行，并结束。

这时，只剩下T3和T4，在此时，两个线程的机会均等。

但是，T3抢到了CPU，于是它执行了，而且唤醒了线程，虽然此时并没有线程休眠。说白了，它浪费了一次notify。T3顺利执行完。

这时，终于轮到了T4，它启动了，wait了，但是，后面已经没有线程了，它的wait永远不会有线程帮它notify了！

于是，它就这么等着！

 

请仔细看执行流程，看懂，再自己做一下试验。

仔看看，你会看到，凡是当前线程的run方法里面写了notify，有了start马上就会end，而如果是写的wait，有了start，下一个绝对不是输出这个线程的end。

所以说，T2和T3由于是写的notify，它们的start和end总是成对出现。而T1和T4由于是写的wait，它们start后，下一个绝不可能是它的end。

最后再提醒一下，我们的wait和notify是针对同一个object的，而非线程。我们这一篇都在讲对象锁，而不是线程。

 

顺便说一下，如果没有线程在wait，调用notify是不会有什么问题的，就像这样：

public class ThreadG {

public static void main(String[] args) {

final Object object = new Object();

Thread t1 = new Thread() {

public void run()

{

synchronized (object) {

System.out.println("T1 start!");

object.notify();

System.out.println("T1 end!");

}

}

};

t1.start();

}

 

}

 

T1 start!

T1 end!