sleep()和wait()有什么区别？

package com.abuge;
/**
 * 需求：sleep()和wait()有什么区别？
 * 第一种解释：
 * 都是用来进行线程控制，本质区别：sleep()不释放同步锁，wait()释放同步锁
 * sleep不出让系统资源，wait是进入线程池等待，出让系统资源，其它线程可以占用CPU。一般
 * wait()不会加时间限制，因为如果wait()线程的运行资源不够，再出来也没用，要等待其它线程
 * 调用notify/notifyAll唤醒等待池中的所有线程，才会进入就绪队列等待OS分配系统资源，
 * 
 * 用法不同：sleep(milleseconds)可以用时间指定来使它自动醒过来，如果时间不到就只能调用
 * interreput()来强行打断，wait()可以用notify()直接唤起
 * 
 * Thread.sleep(0)的作用是触发操作系统立刻重新进行一次CPU竞争
 * 第二种解释：
 * sleep是Thread类的静态方法，sleep的作用是让线程休眠指定时间，在时间到达时恢复，也就是说
 * sleep将在接到时间到达事件恢复线程执行。例如：
 * try
 * {
 * System.out.println("I'm going to bed!");
 * Thread.sleep(1000);
 * System.out.println("I wake up!");
 * }catch(InterruptedException e)
 * {
 * 
 * }
 * wait是Object的方法，也就是说可以对任意一个对象调用wait方法，调用wait方法将会将调用者的
 * 线程挂起，直到其它线程调用同一个对象的notify()方法才会重新激活调用者。例如：
 * try
 * {
 * obj.wait();
 * }catch(InterruptedException e)
 * {
 * 
 * }
 * 
 * wait(),notify(),notifyAll()只能在同步控制方法或者同步控制块里面使用，而sleep()可以在任何地方使用
 * 
 * @author AbuGe
 *
 */
public class MultiThread 
{
		public static void main(String[] args)
		{
	        new Thread(new Thread1()).start();
	        try
	        {
	
	            Thread.sleep(10);
	
	        } catch (InterruptedException e) {
	
	            e.printStackTrace();
	        }
	
	        new Thread(new Thread2()).start(); 
	
		}
		
	
	public static class Thread1 implements Runnable
	{


		@Override
		public void run()
		{
			/**
			 * 由于Thread1和Thread2内部run方法要用同一对象作为监视器，我们这里不能用this,因为在Thread2里面的
			 * this和这个Thread1的this不是同一个对象，我们用MultiThread.class这个字节码对象，当前虚拟机里引用这个变量是，指向的都是同一个对象
			 */
			synchronized (MultiThread.class) 
			{
				System.out.println("Enter Thread1...");
				System.out.println("Thread1 is waiting...............");
				try 
				{
					/**
					 * 释放锁有两种方式：
					 * 1、程序自然离开监视器的范围，也就是离开了synchronized关键字管辖的范围，
					 * 2、另一种方式就是synchronized关键字管辖的代码内部调用监视器的wait方法，这里用的是wait()方法释放锁
					 */
					MultiThread.class.wait();
				} catch (InterruptedException e) 
				{
					e.printStackTrace();
				}
				System.out.println("Thread1 is going on.......");
				System.out.println("Thread1 is being over.......");
			}
		}
		
	}	
		public static class Thread2 implements Runnable
		{


			@Override
			public void run()
			{
				synchronized (MultiThread.class) 
				{
					System.out.println("Enter Thread2...");
					System.out.println("Thread2 notify other thread can release wait status........");
					
					MultiThread.class.notify();
					try 
					{
						/**
						 * 释放锁有两种方式：
						 * 1、程序自然离开监视器的范围，也就是离开了synchronized关键字管辖的范围，
						 * 2、另一种方式就是synchronized关键字管辖的代码内部调用监视器的wait方法，这里用的是wait()方法释放锁
						 */
						
						//由于notify方法并不释放锁， 即使thread2调用下面的sleep方法休息了10毫秒，
						//但thread1仍然不会执行，因为thread2没有释放锁，所以Thread1无法得不到锁。
						Thread.sleep(10);
					} catch (InterruptedException e) 
					{
						e.printStackTrace();
					}
					System.out.println("Thread2 is going on.......");
					System.out.println("Thread2 is being over.......");
				}
			}
	}
}