Java多线程-线程的交互

来源：互联网发布：表单提交json数据编辑：程序博客网时间：2024/06/06 03:36

一、线程交互的基础知识
void notify()：唤醒在此对象监视器上等待的单个线程。
void notifyAll()：唤醒在此对象监视器上等待的所有线程。
void wait()：导致当前的线程等待，直到其他线程调用此对象的 notify()方法或 notifyAll()方法。

当然，wait()还有另外两个重载方法：
void wait(long timeout)：导致当前的线程等待，直到其他线程调用此对象的 notify()方法或 notifyAll()方法，或者超过指定的时间量。
void wait(long timeout, int nanos)：导致当前的线程等待，直到其他线程调用此对象的 notify()方法或 notifyAll()方法，或者其他某个线程中断当前线程，或者已超过某个实际时间量。

关于等待/通知，要记住的关键点是：
必须从同步代码块内调用wait()、notify()、notifyAll()方法。线程不能调用对象上等待或通知的方法，除非它拥有那个对象的锁。

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

例子

package cn.thread;/** * 计算1+2+3 ... +100的和 *  */public class B extends Thread {    int total = 0;    @Override    public void run() {        synchronized (this) {            for (int i = 0; i < 101; i++) {                total += i;            }            //(完成计算了)唤醒在此对象监视器上等待的单个线程，在本例中线程A被唤醒            notify();        }    }}

package cn.thread;/** * 线程的交互 *  */public class A{    public static void main(String[] args) {                B b = new B();        // 启动计算线程        b.start();        // 线程A拥有b对象上的锁。        // 线程为了调用wait()或notify()方法，该线程A必须是那个对象锁的拥有者        synchronized (b) {            try {                System.out.println("等待对象b完成计算。。。");                // 当前线程A等待                b.wait();            } catch (InterruptedException e) {                e.printStackTrace();            }            System.out.println("b对象计算的总和是：" + b.total);        }            }}

等待对象b完成计算。。。b对象计算的总和是：5050

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

加上一下我的理解：

synchronized (b) 导致了b上开启了同步锁。也就是说
只要存在 synchronized (b) 就会等待解锁。
也就是说A里的synchronized(b) {} 就是为了防止在执行的时候 B里的synchronized (this) { } 代码段同时执行。

来个时间线。
1. A: synchronized (b) {
(这时候拿到b的锁，其他同步段不能执行，在等待中)
2.      try {
          System.out.println("等待对象b完成计算。。。");
          b.wait();
          （这时候A放弃b锁，让B执行）
3. B: synchronized (this) {
            for (int i = 0; i < 101; i++) {
                total += i;
            }
            notify();
            （唤醒A）
4. A：继续执行。

二、多个线程在等待一个对象锁时使用notifyAll()
在多数情况下，最好通知等待某个对象的所有线程。如果这样做，可以在对象上使用notifyAll()让所有在此对象上等待的线程冲出等待区，返回到可运行状态。

package cn.thread;/** * 计算1+2+3 ... +100的和 *  * @author 林计钦 * @version 1.0 2013-7-23 上午10:06:04 */public class ThreadSum2 extends Thread {    int total = 0;    @Override    public void run() {        synchronized (this) {            for (int i = 0; i < 101; i++) {                total += i;            }            //通知所有在此对象上等待的线程             notifyAll();        }    }}

package cn.thread;/** * 线程的交互 *  * @author 林计钦 * @version 1.0 2013-7-23 上午10:04:11 */public class ThreadInteractionTest2 extends Thread{    ThreadSum2 sum;        public ThreadInteractionTest2(ThreadSum2 sum){        this.sum=sum;    }        @Override    public void run() {        synchronized (sum) {            try {                System.out.println("等待对象sum完成计算。。。");                // 当前线程ThreadInteractionTest等待                sum.wait();            } catch (InterruptedException e) {                e.printStackTrace();            }            System.out.println("sum对象计算的总和是：" + sum.total);        }    }        public static void main(String[] args) {        ThreadSum2 sum = new ThreadSum2();                //启动三个线程，分别获取计算结果         new ThreadInteractionTest2(sum).start();        new ThreadInteractionTest2(sum).start();        new ThreadInteractionTest2(sum).start();                // 启动计算线程        sum.start();                    }}

等待对象sum完成计算。。。等待对象sum完成计算。。。等待对象sum完成计算。。。sum对象计算的总和是：5050sum对象计算的总和是：5050sum对象计算的总和是：5050

谈一下synchronized和wait()、notify()等的关系:
1、有synchronized的地方不一定有wait,notify
2、有wait,notify的地方必有synchronized.这是因为wait和notify不是属于线程类，而是每一个对象都具有的方法，而且，这两个方法都和对象锁有关，有锁的地方，必有synchronized。
另外，注意一点：如果要把notify和wait方法放在一起用的话，必须先调用notify后调用wait，因为如果调用完wait，该线程就已经不是currentthread了。

0 0