对多线程编程里wait() notify()的精确论述:这一对方法直接隶属于 Object 类，也就是说，所有对象都拥有这一对方法。
初看起来这十分不可思议，但是实际上却是很自然的，因为这一对方法阻塞时要释放占用的锁，而锁是任何对象都具有的，调用任意对象的 wait() 方法导致线程阻塞，并且该对象上的锁被释放。而调用 任意对象的notify()方法则导致因调用该对象的 wait() 方法而阻塞的线程中随机选择的一个解除阻塞（但要等到获得锁后才真正可执行）。
其次，前面叙述的所有方法都可在任何位置调用，但是这一对方法却必须在 synchronized 方法或块中调用，理由也很简单，只有在synchronized 方法或块中当前线程才占有锁，才有锁可以释放。同样的道理，调用这一对方法的对象上的锁必须为当前线程所拥有，这样才有锁可以释放。因此，这一对方法调用必须放置在这样的 synchronized 方法或块中，该方法或块的上锁对象就是调用这一对方法的对象。若不满足这一条件，则程序虽然仍能编译，但在运行时会出现IllegalMonitorStateException 异常
下面的这个例子很好的反映了wait()和notify()或者notifyAll()的用法
public class Main {
/**
* 这是5个工人干活的例子，因为工人的效率不一样,效率高的先完成任务，
* 然后休息,当最后的一个工人完成工作的时候通知所有的人,所有工人又重新开始干活了；
* 线程与线程组编制成了一个线程树,树干是线程组,树叶是线程,而这颗树的根就是系统线程组.
*/
public static void main(String[] args) throws InterruptedException {
Resource r = new Resource(4);
ThreadGroup tg = new ThreadGroup("GT");
new Thread(tg, new Worker(r,8)).start();
new Thread(tg, new Worker(r,12)).start();
new Thread(tg, new Worker(r,22)).start();
new Thread(tg, new Worker(r,16)).start();
new Thread(tg, new Worker(r,20)).start();
new Thread(tg, new Manager()).start();
}
}
public class Worker implements Runnable {
private Resource r;
/**
* the mission
*/
private int efficiency;
public Worker(Resource r,int efficiency){
this.r = r;
this.efficiency = efficiency;
}
public void run() {
int i = 0;
while(true){
System.out.println(Thread.currentThread()+" is working");
i ++;
if(i == efficiency){
i = 0;
r.waitForAll();
}
try {
Thread.currentThread().sleep(1000);
}
catch (InterruptedException ex) {
ex.printStackTrace();
}
}
}
}
public class Worker implements Runnable {
private Resource r;
/**
* the mission
*/
private int efficiency;
public Worker(Resource r,int efficiency){
this.r = r;
this.efficiency = efficiency;
}
public void run() {
int i = 0;
while(true){
System.out.println(Thread.currentThread()+" is working");
i ++;
if(i == efficiency){
i = 0;
r.waitForAll();
}
try {
Thread.currentThread().sleep(1000);
}
catch (InterruptedException ex) {
ex.printStackTrace();
}
}
}
}
/**
* 这是5个工人干活的例子，因为工人的效率不一样,效率高的先完成任务，
* 然后休息,当最后的一个工人完成工作的时候通知所有的人,所有工人又重新开始干活了；
* 线程与线程组编制成了一个线程树,树干是线程组,树叶是线程,而这颗树的根就是系统线程组.
*/
public static void main(String[] args) throws InterruptedException {
Resource r = new Resource(4);
ThreadGroup tg = new ThreadGroup("GT");
new Thread(tg, new Worker(r,8)).start();
new Thread(tg, new Worker(r,12)).start();
new Thread(tg, new Worker(r,22)).start();
new Thread(tg, new Worker(r,16)).start();
new Thread(tg, new Worker(r,20)).start();
new Thread(tg, new Manager()).start();
}
}
public class Worker implements Runnable {
private Resource r;
/**
* the mission
*/
private int efficiency;
public Worker(Resource r,int efficiency){
this.r = r;
this.efficiency = efficiency;
}
public void run() {
int i = 0;
while(true){
System.out.println(Thread.currentThread()+" is working");
i ++;
if(i == efficiency){
i = 0;
r.waitForAll();
}
try {
Thread.currentThread().sleep(1000);
}
catch (InterruptedException ex) {
ex.printStackTrace();
}
}
}
}
public class Worker implements Runnable {
private Resource r;
/**
* the mission
*/
private int efficiency;
public Worker(Resource r,int efficiency){
this.r = r;
this.efficiency = efficiency;
}
public void run() {
int i = 0;
while(true){
System.out.println(Thread.currentThread()+" is working");
i ++;
if(i == efficiency){
i = 0;
r.waitForAll();
}
try {
Thread.currentThread().sleep(1000);
}
catch (InterruptedException ex) {
ex.printStackTrace();
}
}
}
}
