wait()与notify()

一,前言

本文来源:http://www.yu833.com//

,

?

? 简单画了一下线程的流程图,只是一个大概。如图所示,线程有多种状态,那么不同状态之间是如何切换的,下面主要总结关于wait()和notify()的使用。

二,wait()

? wait()和notify()都是定义在Object类中,为什么如此设计。因为synchronized中的这把锁可以是任意对象,所以任意对象都可以调用wait()和notify(),并且只有同一把锁才能对线程进行操作,不同锁之间是不可以相互操作的,所以wait和notify属于Object。请看如下API文档说明。

? wait()提供三种构造方法,但前两种最为常用,wait()是让线程一直处于等待状态,直到手动唤醒,而wait(long timeout)可以指定等待时间,之后会自动唤醒。

?

? 调用wait方法可以让当前线程进入等待唤醒状态,该线程会处于等待唤醒状态直到另一个线程调用了object对象的notify方法或者notifyAll方法。

三,notify()

?

? notify()唤醒等待的线程,如果监视器种只有一个等待线程,使用notify()可以唤醒。但是如果有多条线程notify()是随机唤醒其中一条线程,与之对应的就是notifyAll()就是唤醒所有等待的线程,请看下面实例代码。

? 案例:定义两条线程,分别让其线程等待,及线程唤醒。

? 1,定义线程。

public class SetTarget implements Runnable{
    private Demo demo;
    public SetTarget(Demo demo) {
        this.demo = demo;
    }
    @Override
    public void run() {
        demo.set();
    }
}
public class GetTarget implements Runnable {
    private Demo demo;
    public GetTarget(Demo demo) {
        this.demo = demo;
    }
    @Override
    public void run() {
        demo.get();
    }
}

? 2,编写main方法。

public class Demo {

    /定义一个信号量
    private volatile int signal;

    public static void main(String[] args) {
        
        Demo demo = new Demo();
        SetTarget set = new SetTarget(demo);
        GetTarget get = new GetTarget(demo);
        
        /开启线程,
        new Thread(get).start();
        new Thread(get).start();
        new Thread(get).start();
        new Thread(get).start();
        
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        new Thread(set).start();
    }

    /set方法唤醒线程
    public synchronized void set() {
        signal = 1;
        /notify方法会随机叫醒一个处于wait状态的线程
        notify(); 
        /notifyAll叫醒所有的处于wait线程,争夺到时间片的线程只有一个
        /notifyAll();
        System.out.println("叫醒线程叫醒之后休眠开始...");
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    /get方法使线程进入等待状态
    public synchronized int get() {
        System.out.println(Thread.currentThread().getName() + " 方法执行了...");
        if (signal != 1) {
            try {
                wait();
                System.out.println("叫醒之后");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(Thread.currentThread().getName() + " 方法执行完毕...");
        return signal;
    }
}

? 3,运行结果。

?

? 分析:一共开启了4个线程,当全部进入等待状态时,调用notify()方法唤醒线程,但很明显只唤醒了其中一条线程。右上角显示程序并没有停止,原因就是其他3条线程仍在处于等待状态。

? 使用notifyAll()唤醒线程:

?

四,生产者-消费者模式

? 生产者-消费者模式,生产者生产商品,然后通知消费者进行消费。

? 1,定义生产者

public class Vendor {
    /定义库存数量
    private int count;

    /定义最大库存
    private final int MAX_COUNT = 10;

    public synchronized void production() {
        while (count >= MAX_COUNT) {
            try {
                System.out.println(Thread.currentThread().getName() + "库存数量达到最大值,停止生产。");
                /此时生产线程全部进入等待状态
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        /否则生产商品
        count++;
        System.out.println(Thread.currentThread().getName() + "正在生产商品,当前库存为:" + count);
        notifyAll();

    }

    public synchronized void consumers() {
        while (count <= 0) {
            try {
                System.out.println(Thread.currentThread().getName() + "没有商品了,消费者处于等待状态...");
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        count--;
        System.out.println(Thread.currentThread().getName() + "正在消费,当前库存为:" + count);
        notifyAll();
    }
}

? 2,分别定义两条线程。

public class SetTarget implements Runnable {

    private Vendor vendor;

    public SetTarget(Vendor vendor) {
        this.vendor = vendor;
    }

    @Override
    public void run() {
        while(true){
            vendor.production();
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                /TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

    }
}
public class GetTarget implements Runnable {

    private Vendor vendor;

    public GetTarget(Vendor vendor) {
        this.vendor = vendor;
    }

    @Override
    public void run() {
        while(true){
            vendor.consumers();
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                /TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
}

? 3,主方法。

public class Demo {
    public static void main(String[] args) {
        Vendor vendor = new Vendor();
        SetTarget set = new SetTarget(vendor);
        GetTarget get = new GetTarget(vendor);
        
        /开启线程生产商品
        new Thread(set).start();
        new Thread(set).start();
        new Thread(set).start();
        new Thread(set).start();
        
        /开启消费者线程
        new Thread(get).start();
    }
}

? 4,运行结果。

五,总结

? 线程之间通信就做这么一个简单的总结,以上内容如有错误,欢迎留言指正。

感谢阅读!

?

posted @ 2019-09-28 15:19 奋进的小样 阅读(...) 评论(...) 编辑 收藏
申博娱乐城直营网 菲律宾太阳成娱乐管理网 www.11msc.com www.22msc.com 太阳城娱乐138申博直营网 www.516sun.com
申博太阳城官网直营 太阳娱乐官网登入 申博游戏安卓系统下载 百家乐微信支付充值 申博游戏网站直营网 申博游戏登录直营网
申博游戏安卓系统下载 太阳城开户信誉最好登入 申博官网娱乐城登入 菲律宾申博娱乐直营官网 电子游戏微信支付充值 菲律宾申博娱乐官网