Java线程之间相互通信wait（）&notify（）

最新推荐文章于 2022-05-06 00:33:11 发布

W|J

最新推荐文章于 2022-05-06 00:33:11 发布

阅读量102

点赞数

文章标签： java

本文链接：https://blog.csdn.net/qq_34922830/article/details/119442467

版权

所有类（对象）继承自Object类均实现了notify与wait方法

解释一下线程的六种状态

BLOCKED
受阻塞并且正在等待监视器锁的某一线程的线程状态。

NEW
至今尚未启动的线程的状态。

RUNNABLE
可运行线程的线程状态。

TERMINATED
已终止线程的线程状态。

TIMED_WAITING
具有指定等待时间的某一等待线程的线程状态。

WAITING
某一等待线程的线程状态。

创建三个类

BaoZi（此类作为对象监视器使用，且确保始终是同一个对象）

package com.myThread;

public class BaoZi {
     String  pier ;
     String  xianer ;
     boolean  flag = false ;//包子资源 是否存在  包子资源状态
}

BaoZiPu（为一个执行周期内第一个执行的类）此类实现了Runnable接口，亦可继承Thread类

package com.myThread;

public class BaoZiPu implements Runnable {
    private BaoZi baozi;

    public BaoZiPu(BaoZi baozi) {
        this.baozi = baozi;
    }

    @Override
    public void run() {
        int count = 0;
        //造包子
        while (true) {
            //同步
            synchronized (baozi) {
                if (baozi.flag == true) {//包子资源  存在
                    try {
                        baozi.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                // 薄皮  牛肉大葱
                baozi.pier = "薄皮";
                baozi.xianer = "牛肉大葱";
                baozi.flag = true;

                System.out.println("包子造好了：" + baozi.pier + baozi.xianer + System.currentTimeMillis());
                try {
                    //为了实现线程输出不是那么快，让所有线程睡3s
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //唤醒等待线程 （吃货）
                baozi.notify();
            }
        }
    }
}

ChiHuo

package com.myThread;

public class ChiHuo implements Runnable {
    private BaoZi baoZi;

    public ChiHuo(BaoZi baoZi) {

        this.baoZi = baoZi;
    }

    @Override
    public void run() {
        while (true) {
            synchronized (baoZi) {
                if (baoZi.flag == false) {//没包子
                    try {
                        baoZi.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("吃货吃到了" + baoZi.pier + baoZi.xianer + "包子" + System.currentTimeMillis());
                baoZi.flag = false;
                baoZi.notify();
            }
        }
    }
}

注意，单独创建线程的（相对于使用线程池创建），在执行run（）方法时出现异常线程会终止的，建议run（）方法捕获异常

ChiHuo、BaoZiPu都有BaoZi属性，并且此属性设值放在了构造方法中

Test

public class Test {
    public static void main(String[] args) {
        BaoZi baoZi = new BaoZi();
//实现接口的方式 需要通过new Thread的方式创建线程
//Thread(Runnable target) 分配新的 Thread 对象。
//。 通过 start（）方法运行
        new Thread(new BaoZiPu(baoZi)).start();
        new Thread(new ChiHuo(baoZi)).start();

//        这两个方式需要 BaoZiPu、ChiHuo 继承Threadl 类
//        new BaoZiPu(baoZi).start();

//        new ChiHuo(baoZi).start();
    }
}

执行结果

包子造好了：薄皮牛肉大葱1628212510191
吃货吃到了薄皮牛肉大葱包子1628212513191
包子造好了：薄皮牛肉大葱1628212513191
吃货吃到了薄皮牛肉大葱包子1628212516191
包子造好了：薄皮牛肉大葱1628212516191
吃货吃到了薄皮牛肉大葱包子1628212519191
包子造好了：薄皮牛肉大葱1628212519191

因为是线程间的通信，只能用THread.sleep 方法停止。不可使用 wait(long timeout)、wait(long timeout, int nanos)

Thread构造方法摘要

Thread()
分配新的 Thread 对象。

Thread(Runnable target)
分配新的 Thread 对象。

Thread(Runnable target, String name)
分配新的 Thread 对象。

Thread(String name)
分配新的 Thread 对象。

Thread(ThreadGroup group, Runnable target)
分配新的 Thread 对象。

Thread(ThreadGroup group, Runnable target, String name)
分配新的 Thread 对象，以便将 target 作为其运行对象，将指定的 name 作为其名称，并作为 group 所引用的线程组的一员。

Thread(ThreadGroup group, Runnable target, String name, long stackSize)
分配新的 Thread 对象，以便将 target 作为其运行对象，将指定的 name 作为其名称，作为 group 所引用的线程组的一员，并具有指定的堆栈大小。

Thread(ThreadGroup group, String name)
分配新的 Thread 对象。