我想应该有很多办法，如果是简单的1：1关系，那么可以wait（）和notify（）解决，就像一把锁和一把钥匙；如果是1：N关系，这个1就需要关心N的所有状态了，最笨的办法是1可以去查看N当前的状态，轮询询问工作是否做完。而好点的办法是N做完后主动告诉1，然后N就会有2种选择，要么听从1的命令，要么继续干自己其他的活。

    用传统的方法我想应该是都能实现的，而JDK1.5提供了CyclicBarrier与CountDownLatch来解决了这两个问题，而她们的区别是：

    CyclicBarrier使所有线程相互等待，而CountDownLatch使一个或多个线程等待其他线程。区别类似上面蓝色字体，CountDownLatch不会等待其他线程了，只要做完自己的工作就干自己的活去了，也就是run()方法里其他的任务。

Example：

public static void testCountDownLatch() throws InterruptedException{   
  CountDownLatch cdl=new CountDownLatch(2);   
  ExecutorService exe=Executors.newFixedThreadPool(2);   
   class Bow implements  Runnable{   
    CountDownLatch cdl;   
    public Bow(CountDownLatch cdl){   
    this.cdl=cdl;    
    }   
    public void run(){   
     System.out.println("The bow is coming");   
     System.out.println("kick a bow ");   
     this.cdl.countDown();   
     System.out.println("do other thing");   
     }   
   }   
  exe.execute(new Bow(cdl));   
  exe.execute(new Bow(cdl));   
  exe.shutdown();   
  System.out.println("Wait");   
    cdl.await();   
    System.out.println("End..");   
    
 }   
  
    public static void main(String[] args) {   
        try {   
            Test.testCountDownLatch();   
        } catch (InterruptedException e) {   
        }   
    }  

输出的结果为：

The bow is coming
kick a bow
do other thing
Wait...
The bow is coming
kick a bow
do other thing
End..

如上所说do other thing不受影响。

写了一个CyclicBarrier的例子：

public static void testCyclicBarrier() throws InterruptedException, BrokenBarrierException{
        CyclicBarrier barr=new CyclicBarrier(2+1);
        
        ExecutorService exe=Executors.newFixedThreadPool(2);
         class Bow implements  Runnable{
             CyclicBarrier barr;
                public Bow(CyclicBarrier barr){
                this.barr=barr;    
                }
                public void run(){
                    System.out.println("The bow is coming");
                    System.out.println("kick a down");
                    try {
                        barr.await();
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    } catch (BrokenBarrierException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    System.out.println("do other thing");
                    }
            }
        exe.execute(new Bow(barr));
        exe.execute(new Bow(barr));
        exe.shutdown();
        System.out.println("Wait");
        barr.await();
       System.out.println("End..");
    
    }


    public static void main(String[] args) {
        try {
            Test.testCyclicBarrier();
        } catch (InterruptedException e) {
        }
        catch (BrokenBarrierException e) {
        }
    }

输出结果为：

Wait...
The bow is coming
kick a down
The bow is coming
kick a down
do other thing
End..
do other thing

总结：

我们看到do other thing被阻塞了，直到最后才执行，可见，栅栏和计数器的目完全不同了。向Doug Lea牛人学习：）

 









在网上看到很多人对于CountDownLatch和CyclicBarrier的区别简单理解为CountDownLatch是一次性的，而CyclicBarrier在调用reset之后还可以继续使用。那如果只是这么简单的话，我觉得CyclicBarrier简单命名为ResetableCountDownLatch好了，显然不是的。
我的理解是，要从他们的设计目的去看这两个类。javadoc里面的描述是这样的。

CountDownLatch: A synchronization aid that allows one or more threads to wait until a set of operations being performed in other threads completes.

CyclicBarrier : A synchronization aid that allows a set of threads to all wait for each other to reach a common barrier point.

可能是我的英语不够好吧， 我感觉从这个javadoc里面要准确理解他们的差异还是不容易的。
我的理解是

CountDownLatch : 一个线程(或者多个)， 等待另外N个线程完成某个事情之后才能执行。   CyclicBarrier        : N个线程相互等待，任何一个线程完成之前，所有的线程都必须等待。
这样应该就清楚一点了，对于CountDownLatch来说，重点是那个“一个线程”, 是它在等待， 而另外那N的线程在把“某个事情”做完之后可以继续等待，可以终止。而对于CyclicBarrier来说，重点是那N个线程，他们之间任何一个没有完成，所有的线程都必须等待。

CountDownLatch 是计数器, 线程完成一个就记一个, 就像 报数一样, 只不过是递减的.
而CyclicBarrier更像一个水闸, 线程执行就想水流, 在水闸处都会堵住, 等到水满(线程到齐)了, 才开始泄流.

      wait方法可以使在当前线程的对象等待，直到别的线程调用此对象的notify或notifyAll方法（注意：调用的是此对象的notify和notifyAll），并且当前运行的线程必须具有此对象的对象监视器

package com.abin.lee.thread.thread;

public class CarryTask extends Thread {
 public void run() {
        try {
            synchronized (this) {
                Thread t = Thread.currentThread();
                System.out.println(t.getId() + t.getName() + ":task start, wait for notify...");
                this.wait();
                System.out.println(t.getId() + t.getName() + ":task continue...");
            }
        } catch (InterruptedException ex) {
           System.out.println(CarryTask.class.getName());
        }
    }

}

package com.abin.lee.thread.thread;

public class CarryWait {
 public static void main(String[] args) throws InterruptedException {
  CarryTask task = new CarryTask();
  Thread t = Thread.currentThread();
  System.out.println(t.getId() + t.getName() + ":task start...");
  task.start();
  Thread.sleep(2000);
  synchronized (task) {
   System.out.println("id="+Thread.currentThread().getId()+",Name="+Thread.currentThread().getName()+",task="+task+",notify");
   task.notify();
  }
 }

}

package net.abin.lee.mythread.callable;

import java.util.concurrent.Callable;
import java.util.concurrent.Semaphore;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class FutureGo implements Callable<String> {
 private String message;
 private static final Semaphore semaphore=new Semaphore(3);
 private final ReentrantReadWriteLock rwl=new ReentrantReadWriteLock();
 public FutureGo(String message) {
  this.message = message;
 }

 public String call() throws InterruptedException {
  semaphore.acquire();
  Lock read=rwl.readLock();
  Lock write=rwl.readLock();
  read.lock();  
  System.out.println("message"+message+",Name"+Thread.currentThread().getName()+"进来了");
  read.unlock();
  write.lock();
  String result=message+"你好!";
  Thread.sleep(1000);
  System.out.println("message"+message+"Name"+Thread.currentThread().getName()+"离开了");
  write.unlock();
  semaphore.release();
  return result;
 }
}



//FutureTaskTest.java

package net.abin.lee.mythread.callable;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;

public class FutureTaskTest {
 public static void main(String[] args) throws InterruptedException,
   ExecutionException {
  Callable<String> go = new FutureGo("abin");
  FutureTask<String> task = new FutureTask<String>(go);
  ExecutorService executor = Executors.newCachedThreadPool();
  if (!executor.isShutdown()) {
   executor.execute(task);
  }
  String result = "";
  if (!task.isDone()) {
   result = (String) task.get();
   System.out.println("result=" + result);
  }
   executor.shutdown();
 }

}

//实例一，这里面用到了信号量Semaphore和FutureTask

Semaphore实现的功能就类似厕所有5个坑，假如有10个人要上厕所，那么同时只能有多少个人去上厕所呢？同时只能有5个人能够占用，当5个人中 的任何一个人让开后，其中等待的另外5个人中又有一个人可以占用了。另外等待的5个人中可以是随机获得优先机会，也可以是按照先来后到的顺序获得机会，这取决于构造Semaphore对象时传入的参数选项。单个信号量的Semaphore对象可以实现互斥锁的功能，并且可以是由一个线程获得了“锁”，再由另一个线程释放“锁”，这可应用于死锁恢复的一些场合。

Semaphore维护了当前访问的个数，提供同步机制，控制同时访问的个数。在数据结构中链表可以保存“无限”的节点，用Semaphore可以实现有限大小的链表。另外重入锁 ReentrantLock 也可以实现该功能，但实现上要复杂些。 

下面的Demo中申明了一个只有5个许可的Semaphore，而有20个线程要访问这个资源，通过acquire()和release()获取和释放访问许可。

package com.test;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.concurrent.Semaphore;

public class TestSemaphore {

                public static void main(String[] args) {

                // 线程池

                ExecutorService exec = Executors.newCachedThreadPool();

                // 只能5个线程同时访问

                final Semaphore semp = new Semaphore(5);

                 // 模拟20个客户端访问

                 for (int index = 0; index < 20; index++) {

                              final int NO = index;

                              Runnable run = new Runnable() {

                                                 public void run() {

                                                            try {

                                                                    // 获取许可

                                                                    semp.acquire();

                                                                    System.out.println("Accessing: " + NO);

                                                                    Thread.sleep((long) (Math.random() * 10000));

                                                                    // 访问完后，释放

                                                                    semp.release();

                                                                    System.out.println("-----------------"+semp.availablePermits());

                                                            } catch (InterruptedException e) {

                                                                    e.printStackTrace();

                                                            }

                                                  }

                                      };

                      exec.execute(run);

             }

             // 退出线程池

             exec.shutdown();

       }

} 

执行结果如下：

Accessing: 0

Accessing: 1

Accessing: 3

Accessing: 4

Accessing: 2

-----------------0

Accessing: 6

-----------------1

Accessing: 7

-----------------1

Accessing: 8

-----------------1

Accessing: 10

-----------------1

Accessing: 9

-----------------1

Accessing: 5

-----------------1

Accessing: 12

-----------------1

Accessing: 11

-----------------1

Accessing: 13

-----------------1

Accessing: 14

-----------------1

Accessing: 15

-----------------1

Accessing: 16

-----------------1

Accessing: 17

-----------------1

Accessing: 18

-----------------1

Accessing: 19

    CachedThreadPool首先会按照需要创建足够多的线程来执行任务(Task)。随着程序执行的过程，有的线程执行完了任务，可以被重新循环使用时，才不再创建新的线程来执行任务。我们采用《Thinking In Java》中的例子来分析。

    首先，任务定义如下(实现了Runnable接口，并且复写了run方法)：

2.FixedThreadPool

     FixedThreadPool模式会使用一个优先固定数目的线程来处理若干数目的任务。规定数目的线程处理所有任务，一旦有线程处理完了任务就会被用来处理新的任务(如果有的话)。这种模式与上面的CachedThreadPool是不同的，CachedThreadPool模式下处理一定数量的任务的线程数目是不确定的。而FixedThreadPool模式下最多 的线程数目是一定的。

    采用FixedThreadPool模式编写客户端程序如下：

3.SingleThreadExecutor模式

    SingleThreadExecutor模式只会创建一个线程。它和FixedThreadPool比较类似，不过线程数是一个。如果多个任务被提交给SingleThreadExecutor的话，那么这些任务会被保存在一个队列中，并且会按照任务提交的顺序，一个先执行完成再执行另外一个线程。

    SingleThreadExecutor模式可以保证只有一个任务会被执行。这种特点可以被用来处理共享资源的问题而不需要考虑同步的问题。

    SingleThreadExecutor模式编写的客户端程序如下： 

package com.abin.lee.thread;

import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
public class ThreadSync{
 
 public static List<Object> ThreadSync(final String message) throws InterruptedException{
  final List<Object> list=new LinkedList<Object>();
  Thread thread=new Thread(){
   public void run(){
    if(message.equals("one")){
     list.add(0, message);
    }
   }
  };
  thread.start();
  thread.join();
  return list;
 }
 
 public static void main(String[] args) throws InterruptedException {
  List<Object> list=ThreadSync("one1");
  System.out.println("size="+list.size());
  for(Iterator it=list.iterator();it.hasNext();){
   Object obj=(Object)it.next();
   System.out.println("obj="+obj);
  }
  
 }
}




方法二：

如果不是，该如何实现阻塞父线程但继续执行子线程？

不是，这个问题属于线程调度。
让一个线程明确的给另外一个线程运行机会，采用以下方法：
1.调整线程优先级
2.让处于运行状态的线程调用Thread.sleep（）方法
3.让处于运行状态的线程调用Thread.yield（）方法
4.让处于运行状态的线程调用另外一个线程的jion（）方法

 题目的意思很容易理解，可是要做出这道题目需要对多线程的基本改进非常的理解。

下面列出基本思路：

主线程想获取obj的锁，但是获取不到，说明子线程始终在占据着这个对象的锁。

同时主线程又能返回。

那现在就要实现让子线程先跑，然后再唤醒主线程。这个显然是锁的占有和唤醒，那么问题来了，将什么做为这个锁呢？如果是obj的话，不可能，因为子线程显然不能在放掉obj.

那么只能是子线程自己的锁。

下边是程序

import java.util.concurrent.atomic.AtomicInteger;

public class SumThread implements Runnable{
 private  AtomicInteger num=new AtomicInteger(0);
 public void run(){
  while(num.get()<100){
   try {
    Thread.sleep(100);
   } catch (InterruptedException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
   }
   if(num.get()==40){
    Thread thread2=new Thread(this,"thread2");
    thread2.start();
   }
   System.out.println(Thread.currentThread().getName()+":"+num.getAndIncrement());
  }
 }
 
}

package com.abin.lee.servlet.mythread.runnable;

public class SumThreadTest {
 public static void main(String[] args) {
  SumThread ru=new SumThread();
  Thread thread1=new Thread(ru,"thread1");
  thread1.start();
 }
}

两个不同的线程总是看到某个成员变量的同一个值。

Java语言规范中指出：为了获得最佳速度，允许线程保存共享成员变量的私有拷贝，而且只当线程进入或者离开同步代码块时才与共享成员变量的原始值对比。

这样当多个线程同时与某个对象交互时，就必须要注意到要让线程及时的得到共享成员变量的变化。

而volatile关键字就是提示VM：对于这个成员变量不能保存它的私有拷贝，而应直接与共享成员变量交互。

使用建议：在两个或者更多的线程访问的成员变量上使用volatile。当要访问的变量已在synchronized代码块中，或者为常量时，不必使用。

由于使用volatile屏蔽掉了VM中必要的代码优化，所以在效率上比较低，因此一定在必要时才使用此关键字。 


就跟C中的一样 禁止编译器进行优化~~~~

在java线程并发处理中，有一个关键字volatile的使用目前存在很大的混淆，以为使用这个关键字，在进行多线程并发处理的时候就可以万事大吉。

Java语言是支持多线程的，为了解决线程并发的问题，在语言内部引入了 同步块 和 volatile 关键字机制。

synchronized 

同步块大家都比较熟悉，通过 synchronized 关键字来实现，所有加上synchronized 和 块语句，在多线程访问的时候，同一时刻只能有一个线程能够用

synchronized 修饰的方法 或者 代码块。

volatile

用volatile修饰的变量，线程在每次使用变量的时候，都会读取变量修改后的最的值。volatile很容易被误用，用来进行原子性操作。

下面看一个例子，我们实现一个计数器，每次线程启动的时候，会调用计数器inc方法，对计数器进行加一

执行环境——jdk版本：jdk1.6.0_31 ，内存 ：3G   cpu：x86 2.4G

运行结果:Counter.count=992

运行结果还是没有我们期望的1000，下面我们分析一下原因

在 java 垃圾回收整理一文中，描述了jvm运行时刻内存的分配。其中有一个内存区域是jvm虚拟机栈，每一个线程运行时都有一个线程栈，

线程栈保存了线程运行时候变量值信息。当线程访问某一个对象时候值的时候，首先通过对象的引用找到对应在堆内存的变量的值，然后把堆内存

变量的具体值load到线程本地内存中，建立一个变量副本，之后线程就不再和对象在堆内存变量值有任何关系，而是直接修改副本变量的值，

在修改完之后的某一个时刻（线程退出之前），自动把线程变量副本的值回写到对象在堆中变量。这样在堆中的对象的值就产生变化了。下面一幅图

描述这写交互

read and load 从主存复制变量到当前工作内存
use and assign  执行代码，改变共享变量值
store and write 用工作内存数据刷新主存相关内容

其中use and assign 可以多次出现

但是这一些操作并不是原子性，也就是 在read load之后，如果主内存count变量发生修改之后，线程工作内存中的值由于已经加载，不会产生对应的变化，所以计算出来的结果会和预期不一样

对于volatile修饰的变量，jvm虚拟机只是保证从主内存加载到线程工作内存的值是最新的

例如假如线程1，线程2 在进行read,load 操作中，发现主内存中count的值都是5，那么都会加载这个最新的值

在线程1堆count进行修改之后，会write到主内存中，主内存中的count变量就会变为6

线程2由于已经进行read,load操作，在进行运算之后，也会更新主内存count的变量值为6

导致两个线程及时用volatile关键字修改之后，还是会存在并发的情况。

package com.abin.lee.servlet.mythread.thread;

public class Mythread extends Thread{
 private String name;
 public Mythread(String name) {
  this.name=name;
 }
 public void run() {
  synchronized(this.name){
   System.out.println("开始时间："+System.currentTimeMillis()+",线程名字："+Thread.currentThread().getName());
   System.out.println("name="+name);
   System.out.println("结束时间："+System.currentTimeMillis()+",线程名字："+Thread.currentThread().getName());
 
  }
 }
 
}

package com.abin.lee.servlet.mythread.thread;

public class MythreadTest {
 public static void main(String[] args) {
  Mythread mythread1=new Mythread("ManyThread");
  Mythread mythread2=new Mythread("ManyThread");
  mythread1.start();
  mythread2.start();
 }

}

package com.abin.lee.servlet.mythread.runnable;

public class MyRunnable implements Runnable{
 private String name;
 public MyRunnable(String name) {
  this.name=name;
 }
 public synchronized void run(){
   System.out.println("开始时间："+System.currentTimeMillis()+",线程名字："+Thread.currentThread().getName());
   System.out.println("name="+name);
   try {
    Thread.sleep(3000);
   } catch (InterruptedException e) {
    e.printStackTrace();
   }
   System.out.println("结束时间："+System.currentTimeMillis()+",线程名字："+Thread.currentThread().getName());
 }
}

package com.abin.lee.servlet.mythread.runnable;

public class MyRunnableTest {
 public static void main(String[] args) {
  MyRunnable myRunnable=new MyRunnable("ManyThread");
  Thread thread1=new Thread(myRunnable);
  Thread thread2=new Thread(myRunnable);
  thread1.start();
  thread2.start();
 }
}

package com.abin.lee.servlet.mythread.callable;

import java.util.concurrent.Callable;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class MyCallable implements Callable<String>{
 private String name;
 public MyCallable(String name) {
  this.name=name;
 }
 public String call() throws Exception {
  Lock lock=new ReentrantLock();
  lock.lock();
  String result="";
  try {
   System.out.println("开始时间："+System.currentTimeMillis()+",线程名字："+Thread.currentThread().getName());
   System.out.println("name="+name);
   if(name.equals("ManyThread")){
    result="success";
   }else{
    result="failure";
   }
   try {
    Thread.sleep(3000);
   } catch (InterruptedException e) {
    e.printStackTrace();
   }
   System.out.println("结束时间："+System.currentTimeMillis()+",线程名字："+Thread.currentThread().getName());
 
  } catch (Exception e) {
   e.printStackTrace();
  }finally{
   lock.unlock();
  }
     return result;  
 }
 
}

package com.abin.lee.servlet.mythread.callable;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

import org.junit.Test;

public class MyCallableTest {
 @Test
 public void testMyCallable() throws InterruptedException, ExecutionException{
  ExecutorService executor=Executors.newFixedThreadPool(3);
  MyCallable myCallable=new MyCallable("ManyThread");
  Future future1=executor.submit(myCallable);
  System.out.println("future1="+future1.get());
  Future future2=executor.submit(myCallable);
  System.out.println("future2="+future2.get());
  Future future3=executor.submit(myCallable);
  System.out.println("future3="+future3.get());
  
 }

}

测试结果：

问题解决2——加入等待与唤醒

package edu.sjtu.erplab.thread;

class Info{
    private String name="name";
    private String content="content";
    private boolean flag=true;
    public  synchronized void set(String name,String content)
    {
        if(!flag)//标志位为false，不可以生产
        {
            try {
                super.wait();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        this.setName(name);
        try {
            Thread.sleep(30);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        this.setContent(content);
        flag=false;//修改标志位为false，表示生产者已经完成资源，消费者可以消费。
        super.notify();//唤醒消费者进程
    }
   
    public synchronized void get()
    {
        if(flag)
        {
            try {
                super.wait();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        try {
            Thread.sleep(30);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println(this.getName()+":-->"+this.getContent());
        flag=true;//修改标志位为true，表示消费者拿走资源，生产者可以生产。
        super.notify();//唤醒生产者进程。
    }
   
   
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getContent() {
        return content;
    }
    public void setContent(String content) {
        this.content = content;
    }
   
}

class Producer implements Runnable{
    private Info info=null;
    public Producer(Info info)
    {
        this.info=info;
    }
   

    @Override
    public void run() {
        boolean flag=false;
        for(int i=0;i<10;i++)
            if(flag)
            {
                this.info.set("name+"+i, "content+"+i);
                flag=false;
            }
            else
            {
                this.info.set("name-"+i, "content-"+i);
                flag=true;
            }
    }
}

class Consumer implements Runnable{
    private Info info=null;
    public Consumer(Info info)
    {
        this.info=info;
    }
    @Override
    public void run() {
        for(int i=0;i<10;i++)
        {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            this.info.get();
        }
       
    }
}

public class ThreadDeadLock {
    public static void main(String args[])
    {
        Info info=new Info();
        Producer pro=new Producer(info);
        Consumer con=new Consumer(info);
        new Thread(pro).start();
        new Thread(con).start();
    }
   
}




http://www.cnblogs.com/xwdreamer/archive/2011/11/20/2296931.html#2397397

区别一：

sleep是Thread类的方法，是线程用来 控制自身流程的，比如有一个要报时的线程，每一秒中打印出一个时间，那么我就需要在print方法前面加上一个sleep让自己每隔一秒执行一次。就像个闹钟一样。

wait是Object类的方法，用来线程间的通信，这个方法会使当前拥有该对象锁的进程等待知道其他线程调用notify方法时再醒来，不过你也可以给他指定一个时间，自动醒来。这个方法主要是用走不同线程之间的调度的。

区别二 ：

关于锁的释放 ，在这里假设大家已经知道了锁的概念及其意义。调用sleep方法不会释放锁（自己的感觉是sleep方法本来就是和锁没有关系的，因为他是一个线程用于管理自己的方法，不涉及线程通信）

JDK 7 中的解释：

“public static void sleep(long millis)

throws InterruptedException
Causes the currently executing thread to sleep (temporarily cease execution) for the specified number of milliseconds, subject to the precision and accuracy of system timers and schedulers.The thread does not lose ownership of any monitors.

public final void wait() throws InterruptedException
Causes the current thread to wait until another thread invokes the notify() method or the notifyAll() method for this object. In other words, this method behaves exactly as if it simply performs the call wait(0).The current thread must own this object's monitor. The thread releases ownership of this monitor and waits until another thread notifies threads waiting on this object's monitor to wake up either through a call to the notify method the notifyAll method. The thread then waits until it can re-obtain ownership of the monitor and resumes execution.“
调用wait方法会释放当前线程的锁（其实线程间的通信是靠对象来管理的，所有操作一个对象的线程是这个对象通过自己的wait方法来管理的，就好像这个对象是电视机，三个人是三个线程，那么电视机的遥控器就是这个锁，假如现在A拿着遥控器，电视机调用wait方法，那么A就交出自己的遥控器，由jVM虚拟机调度，遥控器该交给谁。）【我想到一个好玩的例子：如果A拿遥控器的期间，他可以用自己的sleep每隔十分钟调一次电视台，而在他调台休息的十分钟期间，遥控器还在他的手上~】

区别三：

使用区域

由于wait函数的特殊意义，所以他是应该放在同步语句块中的，这样才有意义 。

注意：两个方法都需要抛出异常

个人见解：有sleep和wait的第二个区别，引起了我对Java线程机制的一个疑问，目前还没有看过JDk这方面的源码（其实看了，是木有看懂），线程的同步管理，是不是由对象在调度，如果是对象在调度，那么JDK 1.5新引入的ReentrantLock机制就比synchronized关键字更值得提倡。因为他更能反映出这么一个机制来。好多人不能理解wait和sleep的区别，我认为就是因为synchronized关键字的影响。当然自己还不懂JAVA的线程具体实现，留作疑问以后有时间继续研究吧