Java线程：线程交互

一、基础知识

　　java.lang.Object的类的三个方法：

　　　　void notify():唤醒在此对象监视器上等待的单个线程。

　　　　void notifyAll():唤醒在此对象监视器上等待的所有线程。

　　　　void wait():导致当前线程等待，直到其他线程调用此对象的notify()方法或notifyAll()方法。

　　　　void wait(long timeout):导致当前线程等待，直到其他线程调用此对象的notify()方法或notifyAll()方法,或者是超过指定时间。

　　　　void wait(long timeout,int nanos):导致当前线程等待，直到其他线程调用此对象的notify()方法或notifyAll()方法，或者是其他某个线程中断当前线程，或超过某个实际时间。

以上方法使用要点：

　　必须从同步环境中调用这些方法。线程不能调用对象上等待或通知的方法，除非它拥有那个对象的锁。

　　以上几种方法都是Object的实例方法，与每个对象具有锁是一样的，每个对象可以有一个线程列表，它们等待来自该信号。线程通过wait()获得这个等待列表。它不再执行任何其他指令，直到调用notify()为止。如果多个线程在同一个对象上等待，则将只选择一个线程继续执行。如果没有线程等待，则不采取操作。如；

　　

package Thread;

public class Test2 {
    public static void main(String[] args){
        ThreadB b=new ThreadB();
        b.start();//线程A拥有b对象上的锁。线程为了调用wait()或notify()方法，该线程必须是那个对象锁的拥有者
        synchronized(b){
            try{
                System.out.println("等待对象b完成计算...>");
                b.wait();//当前线程A等待
            }catch(InterruptedException e){
                e.printStackTrace();
            }
            System.out.println("b对象计算完毕，其总和是："+b.total);
        }
    }
}    
class ThreadB extends Thread{
    int total;
    public void run(){
        synchronized(this){
            for(int i=0;i<101;i++){
                total+=i;
            }
            notify();//（完成计算）唤醒在此对象监视器上等待的单个线程，在本例中A被唤醒。
        }
    }
}

等待对象b完成计算...>
b对象计算完毕，其总和是：5050

　　在对象上调用wait()方法时，执行该代码的线程立刻放弃它在该对象的锁，然后调用调用notify()方法，如果线程仍然在完成同步代码，则线程移出之前不会放弃锁。因此，只要调用notify()并不意味着这时的锁变得可用。

二、多个线程在等待一个对象锁时使用notifyAll()

　　多数情况下，最好通知等待某个对象的所有线程。如果这样做，可以在对象上使用notifyAll()方法，让所有等待的线程返回到可运行状态。如：

package Thread;

public class Test2 extends Thread{    
    public static void main(String[] args){
        Calculator calculator=new Calculator();
        new Test2(calculator).start();
        new Test2(calculator).start();
        new Test2(calculator).start();
        calculator.start();//线程A拥有b对象上的锁。线程为了调用wait()或notify()方法，该线程必须是那个对象锁的拥有者        
    }
    Calculator calculator;
    public Test2(Calculator calculator){
        this.calculator=calculator;
    }
    public void run(){
        synchronized(calculator){
            try{
                System.out.println(Thread.currentThread()+"等待计算结果...>");
                calculator.wait();//当前线程A等待
            }catch(InterruptedException e){
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread()+"结果为："+calculator.total);
        }        
    }
}    
class Calculator extends Thread{
    int total;
    public void run(){
        synchronized(this){
            for(int i=0;i<101;i++){
                total+=i;
            }
            notifyAll();//（完成计算）唤醒在此对象监视器上等待的单个线程，在本例中A被唤醒。
        }
    }
}

Thread[Thread-1,5,main]等待计算结果...>
Thread[Thread-3,5,main]等待计算结果...>
Thread[Thread-2,5,main]等待计算结果...>
Thread[Thread-2,5,main]结果为：5050
Thread[Thread-3,5,main]结果为：5050
Thread[Thread-1,5,main]结果为：5050