Java中sleep⽅法和wait⽅法的区别？
Java中的sleep和wait⽅法都是线程Thread⾥边的概念。如果想了解这两个⽅法之间的区别。从根本上你得了解线程Thread的六⼤状态，上边的这两个⽅法的执⾏就会导致，线程状态的转换。
1. 线程的六⼤状态：
1）六⼤状态概述：
NEW：线程刚创建
RUNNABLE：在JVM中正在运⾏的线程
BLOCKED：线程处于阻塞状态，等待监视锁，可以重新进⾏同步代码块中执⾏
WAITING：等待状态
TIMED_WAITING：调⽤sleep() join() wait()⽅法可能导致线程处于等待状态
TERMINATED：线程执⾏完毕，已经退出
2）六⼤状态图：
学习按摩3）六⼤状态简单解读
从图中可以清晰的看出，sleep和wait⽅法处在什么位置。接下来具体介绍⼀下，这两个⽅法的具体应⽤。
2. sleep和wait⽅法的具体应⽤：
1）sleep 休眠⽅法：
Static void sleep(long ms)
盂兰盆经
该⽅法会使当前线程进⼊阻塞状态指定毫秒，当阻塞指定毫秒后，当前线程会重新进⼊Runnable状态，等待划分时间⽚。
2）wait⽅法⼀般是跟notify⽅法连⽤的：
多线程之间需要协调⼯作。如果条件不满⾜则等待。当条件满⾜时，等待该条件的线程将被唤醒。在Java中，这个机制实现依赖于
wait/notify。
3. 这两个⽅法的详细介绍：
想要详细了解这两个⽅法，甚⾄是多线程的同学，可以参考，我写的两篇技术⽂章，⾮常详细：
Java：线程的六⼤状态、基于代码实战的线程创建及六个常⽤⽅法
Java：线程并发问题、基于代码实战的4种锁机制及多线程协作编程
Java中的多线程是⼀种抢占式的机制⽽不是分时机制。线程主要有以下⼏种状态：可运⾏，运⾏，阻塞，死亡。抢占式机制指的是有多个线程处于可运⾏状态，但是只有⼀个线程在运⾏。
当有多个线程访问共享数据的时候，就需要对线程进⾏同步。线程中的⼏个主要⽅法的⽐较：
Thread类的⽅法：sleep(),yield()等
Object的⽅法：wait()和notify()等
每个对象都有⼀个机锁来控制同步访问。Synchronized关键字可以和对象的机锁交互，来实现线程的同步。
由于sleep()⽅法是Thread类的⽅法，因此它不能改变对象的机锁。所以当在⼀个Synchronized⽅法中调⽤sleep（）时，线程虽然休眠了，但是对象的机锁没有被释放，其他线程仍然⽆法访问这个对象。⽽wait()⽅法则会在线程休眠的同时释放掉机锁，其他线程可以访问该对象。
Yield()⽅法是停⽌当前线程，让同等优先权的线程运⾏。如果没有同等优先权的线程，那么Yield()⽅法将不会起作⽤。
⼀个线程结束的标志是：run()⽅法结束。
⼀个机锁被释放的标志是：synchronized块或⽅法结束。
Wait()⽅法和notify()⽅法：当⼀个线程执⾏到wait()⽅法时(线程休眠且释放机锁)，它就进⼊到⼀个和该对象相关的等待池中，同时失去了对象的机锁。当它被⼀个notify()⽅法唤醒时，等待池中的线程就被放到了锁池中。该线程从锁池中获得机锁，然后回到wait()前的中断现场。
join()⽅法使当前线程停下来等待，直⾄另⼀个调⽤join⽅法的线程终⽌。
值得注意的是：线程的在被激活后不⼀定马上就运⾏，⽽是进⼊到可运⾏线程的队列中。
共同点： 他们都是在多线程的环境下，都可以在程序的调⽤处阻塞指定的毫秒数，并返回。
不同点： Thread.sleep(long)可以不在synchronized的块下调⽤，⽽且使⽤Thread.sleep()不会丢失当前线程对任何对象的同步锁(monitor);
object.wait(long)必须在synchronized的块下来使⽤，调⽤了之后失去对object的monitor, 这样做的好处是它不影响其它的线程对object 进⾏操作。
举个java.util.Timer的例⼦来说明。
private void mainLoop() {
while (true) {
....
synchronized(queue) {
.....
if (!taskFired) // Task hasn't yet fired; wait
queue.wait(executionTime - currentTime);
}
}
在这⾥为什么要使⽤queue.wait()，⽽不是Thread.sleep(), 是因为暂时放弃queue的对象锁，可以让允许其它的线程执⾏⼀些同步操作。如：
private void sched(TimerTask task, long time, long period) {
synchronized(queue) {卷贝
...
queue.add(task);
}
}
但是正如上篇⽂章讲到的，使⽤queue.wait(long)的前提条件是sched()动作执⾏的时间很短，否则如果很长，那么queue.wait()不能够按时醒来。
(2)
前⾯讲了wait/notify机制，Thread还有⼀个sleep()静态⽅法，它也能使线程暂停⼀段时间。sleep与wait的不同点是：sleep并不释放锁，并且sleep的暂停和wait暂停是不⼀样的。obj.wait会使线程进⼊obj对象的等待集合中并等待唤醒。
但是wait()和sleep()都可以通过interrupt()⽅法打断线程的暂停状态，从⽽使线程⽴刻抛出InterruptedException。
如果线程A希望⽴即结束线程B，则可以对线程B对应的Thread实例调⽤interrupt⽅法。如果此刻线程B正在wait/sleep/join，则线程B会⽴刻抛出InterruptedException，在catch() {} 中直接return即可安全地结束线程。
需要注意的是，InterruptedException是线程⾃⼰从内部抛出的，并不是interrupt()⽅法抛出的。对某⼀线程调⽤interrupt()时，如果该线程正在执⾏普通的代码，那么该线程根本就不会抛出InterruptedException。但是，⼀旦该线程进⼊到wait()/sleep()/join()后，就会⽴刻抛出InterruptedException。
月份的缩写英文
sleep()、suspend()、resume()⽅法不推荐使⽤，推荐使⽤wait()、notify()、notifyAll()。
sleep()⽅法是使线程停⽌⼀段时间的⽅法。在sleep 时间间隔期满后，线程不⼀定⽴即恢复执⾏。这是因为在那个时刻，其它线程可能正在运⾏⽽且没有被调度为放弃执⾏，除⾮
(a)“醒来”的线程具有更⾼的优先级。
(b)正在运⾏的线程因为其它原因⽽阻塞。
wait()是线程交互时，如果线程对⼀个同步对象x 发出⼀个wait()调⽤，该线程会暂停执⾏，被调对象进⼊等待状态，直到被唤醒或等待时间到。
当调⽤wait()后，线程会释放掉它所占有的“锁标志”，从⽽使线程所在对象中的其它synchronized数据可被别的线程使⽤。
waite()和notify()因为会对对象的“锁标志”进⾏操作，所以它们必须在synchronized函数或synchronized block中进⾏调⽤。如果在non-synchronized函数或non-synchronized block中进⾏调⽤，虽然能编译通过，但在运⾏时会发⽣IllegalMonitorStateException的异常。
(3)
下⾯是我原来在CSDN论坛上看到的⼀个贴⼦，涉及到同步,wait(),notify()等概念的理解，我试着根据原来的⼀些回复和Think in Java上的相关概念将wait()和notify()这两个⽅法剖析了⼀下，欢迎指教.
问题如下：
file://分析这段程序，并解释⼀下，着重讲讲synchronized、wait(),notify 谢谢！
class ThreadA
{
public static void main(String[] args)
{
ThreadB b=new ThreadB();
b.start();
System.out.println("b ");
synchronized(b)//括号⾥的b是什么意思，起什么作⽤?
{
try
{
System.out.println("Waiting for b ");
b.wait();//这⼀句是什么意思，究竟让谁wait?
System.out.println("Completed.Now back to main thread");
}catch (InterruptedException e){}
从军行二首>一射之地
}
System.out.println("Total is :"+b.total);
}
}
class ThreadB extends Thread
{
int total;
public void run()
{
synchronized(this)
{
System.out.println("ThreadB is running..");
for (int i=0;i<100;i++ )
{
total +=i;
System.out.println("total is "+total);
}
notify();
}
}
}
要分析这个程序,⾸先要理解notify()和wait()，为什么在前⼏天记录线程的时候没有纪录这两个⽅法呢，
因为这两个⽅法本来就不属于Thread 类,⽽是属于最底层的object基础类的，也就是说不光是Thread，每个对象都有notify和wait的功能，为什么？因为他们是⽤来操纵锁的,⽽每个对象都有锁，锁是每个对象的基础，既然锁是基础的，那么操纵锁的⽅法当然也是最基础了.
再往下看之前呢,⾸先最好复习⼀下Think in Java的14.3.1中第3部分内容：等待和通知，也就是wait()和notify了.
涛成语
按照Think in Java中的解释:"wait()允许我们将线程置⼊“睡眠”状态，同时⼜“积极”地等待条件发⽣改变.⽽且只有在⼀个notify()或notifyAll()发⽣变化的时候，线程才会被唤醒，并检查条件是否有变."
我们来解释⼀下这句话.
"wait()允许我们将线程置⼊“睡眠”状态"，也就是说,wait也是让当前线程阻塞的，这⼀点和sleep或者suspend是相同的.那和sleep,suspend 有什么区别呢?
区别在于"(wait)同时⼜“积极”地等待条件发⽣改变"，这⼀点很关键,sleep和suspend⽆法做到.因为我们有时候需要通过同步（synchronized）的帮助来防⽌线程之间的冲突，⽽⼀旦使⽤同步，就要锁定对象，也就是获取对象锁，其它要使⽤该对象锁的线程都只能排队等着，等到同步⽅法或者同步块⾥的程序全部运⾏完才有机会.在同步⽅法和同步块中,⽆论sleep()还是suspend()都不可能⾃⼰被调⽤的时候解除锁定，他们都霸占着正在使⽤的对象锁不放.
⽽wait却可以，它可以让同步⽅法或者同步块暂时放弃对象锁,⽽将它暂时让给其它需要对象锁的⼈(这⾥应该是程序块，或线程)⽤，这意味着可在执⾏wait()期间调⽤线程对象中的其他同步⽅法!在其它情况下(sleep啊,suspend啊)，这是不可能的.
关于梅的古诗
但是注意我前⾯说的，只是暂时放弃对象锁，暂时给其它线程使⽤，我wait所在的线程还是要把这个对象锁收回来的呀.wait什么?就是wait别⼈⽤完了还给我啊！
好，那怎么把对象锁收回来呢?
第⼀种⽅法，限定借出去的时间.在wait()中设置参数,⽐如wait(1000)，以毫秒为单位，就表明我只借出去1秒中,⼀秒钟之后，我⾃动收回.
第⼆种⽅法，让借出去的⼈通知我，他⽤完了，要还给我了.这时，我马上就收回来.哎，假如我设了1⼩时之后收回，别⼈只⽤了半⼩时就完了，那怎么办呢?靠!当然⽤完了就收回了，还管我设的是多长时间啊.
那么别⼈怎么通知我呢?相信⼤家都可以想到了,notify()，这就是最后⼀句话"⽽且只有在⼀个notify()或notifyAll()发⽣变化的时候，线程才会被唤醒"的意思了.
因此，我们可将⼀个wait()和notify()置⼊任何同步⽅法或同步块内部，⽆论在那个类⾥是否准备进⾏涉
及线程的处理。⽽且实际上，我们也只能在同步⽅法或者同步块⾥⾯调⽤wait()和notify().
这个时候我们来解释上⾯的程序，简直是易如反掌了.
synchronized(b){...}；的意思是定义⼀个同步块，使⽤b作为资源锁。b.wait()；的意思是临时释放锁，并阻塞当前线程，好让其他使⽤同⼀把锁的线程有机会执⾏，在这⾥要⽤同⼀把锁的就是b线程本⾝.这个线程在执⾏到⼀定地⽅后⽤notify()通知wait的线程，锁已经⽤完，待notify()所在的同步块运⾏完之后,wait所在的线程就可以继续执⾏.
1) sleep()使当前线程进⼊停滞状态，所以执⾏sleep()的线程在指定的时间内肯定不会执⾏；yield()只是使当前线程重新回到可执⾏状态，所以执⾏yield()的线程有可能在进⼊到可执⾏状态后马上⼜被执⾏。
2) sleep()可使优先级低的线程得到执⾏的机会，当然也可以让同优先级和⾼优先级的线程有执⾏的机会；yield()只能使同优先级的线程有执⾏的机会。
