java中sleep和wait的区别

最近在看java的东西。看到了java多线程，注意到sleep和wait，不太清楚它们之间的区别，便在网上找了下，作下记录；

第一种解释：

功能差很少,都用来进行线程控制,他们最大本质的区别是:sleep()不释放同步锁,wait()释放同步缩.   
    
还有用法的上的不一样是:sleep(milliseconds)能够用时间指定来使他自动醒过来,若是时间不到你只能调用interreput()来强行打断;wait()能够用notify()直接唤起.

第二种解释：

sleep是Thread类的静态方法。sleep的做用是让线程休眠制定的时间，在时间到达时恢复，也就是说sleep将在接到时间到达事件事恢复线程执行，例如：

try{
System.out.println("I'm going to bed");
Thread.sleep(1000);
System.out.println("I wake up");
}
catch(IntrruptedException e) {
}

wait是Object的方法，也就是说能够对任意一个对象调用wait方法，调用wait方法将会将调用者的线程挂起，直到其余线程调用同一个对象的notify方法才会从新激活调用者，例如：

//Thread 1

try{
obj.wait();//suspend thread until obj.notify() is called
}
catch(InterrputedException e) {
}

第三种解释：

这二者的施加者是有本质区别的. 
sleep()是让某个线程暂停运行一段时间,其控制范围是由当前线程决定,也就是说,在线程里面决定.比如如说,我要作的事情是 "点火->烧水->煮面",而当我点完火以后我不当即烧水,我要休息一段时间再烧.对于运行的主动权是由个人流程来控制.

而wait(),首先,这是由某个肯定的对象来调用的,将这个对象理解成一个传话的人,当这我的在某个线程里面说"暂停!",也是 thisOBJ.wait(),这里的暂停是阻塞,仍是"点火->烧水->煮饭",thisOBJ就比如一个监督个人人站在我旁边,原本该线程应该执行1后执行2,再执行3,而在2处被那个对象喊暂停,那么我就会一直等在这里而不执行3,但这个流程并无结束,我一直想去煮饭,但还没被容许, 直到那个对象在某个地方说"通知暂停的线程启动!",也就是thisOBJ.notify()的时候,那么我就能够煮饭了,这个被暂停的线程就会从暂停处继续执行.

其实二者均可以让线程暂停一段时间,可是本质的区别是一个线程的运行状态控制,一个是线程之间的通信的问题

在java.lang.Thread类中，提供了sleep()，
而java.lang.Object类中提供了wait()， notify()和notifyAll()方法来操做线程
sleep()能够将一个线程睡眠，参数能够指定一个时间。
而wait()能够将一个线程挂起，直到超时或者该线程被唤醒。
    wait有两种形式wait()和wait(milliseconds).
sleep和wait的区别有：
  1，这两个方法来自不一样的类分别是Thread和Object
  2，最主要是sleep方法没有释放锁，而wait方法释放了锁，使得其余线程可使用同步控制块或者方法。
  3，wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep能够在
    任何地方使用
   synchronized(x){
      x.notify()
     //或者wait()
   }
   4,sleep必须捕获异常，而wait，notify和notifyAll不须要捕获异常

最后附上一个例程，方便理解：

package com.bupt.test;

public class ThreadTest {
	public static void main(String[] args) {
		String lock = "lock";
		MyThread myThread = new MyThread(lock);
		Thread t1 = new Thread(myThread);
		t1.start();
		try {
			// 确保线程t1先执行
			Thread.sleep(2000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		SubThread sub = new SubThread(lock);
		Thread t2 = new Thread(sub);
		t2.start();
	}
}

class MyThread implements Runnable {
	String lock;

	public MyThread(String lock) {
		this.lock = lock;
	}

	public void run() {
		int i = 0;
		// 使用lock对象做为监视器
		synchronized (lock) {
			while (i++ < 20) {
				try {
					// 每次暂停500毫秒是为了更好地看到效果
					Thread.sleep(500);
					System.out.println("The first thread.-->" + i);
					if (i == 10) {
						// 调用lock监视器的wait()方法，通知本线程释放监视器,本线程等待
						// 其余也使用lock对象做为监视器的线程唤醒的时候，本线程得以继续运行
						lock.wait();
						// 下面的wait(long timeout)表示：若等待5秒后尚未别的线程来唤醒的话，则本线程继续执行
						// lock.wait(5000);
					}
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

class SubThread implements Runnable {
	String lock;

	public SubThread(String lock) {
		this.lock = lock;
	}

	public void run() {
		int i = 0;
		// 这个线程也使用lock对象做为监视器
		synchronized (lock) {
			while (i < 10) {
				i++;
				try {
					Thread.sleep(500);
					System.out.println("The second thread.-->" + i);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			// 调用lock对象的notify()方法，唤醒同一对象监视器中调用wait的第一线程
			// 或者调用notifyAll()方法，唤醒同一对象监视器中调用wait的全部线程，具备最高优先级的线程首先被唤醒并执行
			lock.notify();
		}
	}
}