线程间的通信

第一种方法，继承Thread类

模拟篮子的类

package com.commons.commons.backetrunnable;

/**
 * @Author zhaomengxia
 * @create 2019/10/14 16:09
 */
public class Basket {

    private boolean isEmpty;

    public boolean isEmpty() {
        return isEmpty;
    }

    public void setEmpty(boolean empty) {
        isEmpty = empty;
    }
}

生产者：

package com.commons.commons.backetrunnable;

/**
 * @Author zhaomengxia
 * @create 2019/10/14 16:09
 */
public class BasketProducerThread extends Thread {


    private Basket basket;

    public BasketProducerThread(Basket basket) {
        super();
        this.basket = basket;
    }

    @Override
    public void run() {
        while (true) {
            //定义一个同步代码块
            synchronized (basket) {
                try {
                    //如果篮子已有水果，则等待卖出
                    if (!basket.isEmpty()) {
                        //线程等待状态
                        basket.wait();
                    }
                    //唤醒-说明水果卖完-需要生成
                    System.out.println("生成水果！");
                    //生成之后-篮子不为空
                    basket.setEmpty(false);
                    //通知在这个共享对象上等待的线程
                    basket.notify();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

消费者

package com.commons.commons.backetrunnable;

/**
 * @Author zhaomengxia
 * @create 2019/10/14 16:22
 */
public class BasketConsumerRunnable extends Thread {


    private Basket basket;

    public BasketConsumerRunnable(Basket basket) {
        super();
        this.basket = basket;
    }

    @Override
    public void run() {
        while (true) {
            synchronized (basket) {
                try {
                    //篮子为空-等待生成即等待买入
                    if (basket.isEmpty()) {

                        basket.wait();
                    }
                    //唤醒-说明篮子不为空-则进行消费
                    System.out.println("消费！");
                    //消费之后-则篮子不为空
                    basket.setEmpty(true);
                    basket.notify();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

 测试

package com.commons.commons.backetrunnable;

/**
 * @Author zhaomengxia
 * @create 2019/10/14 16:27
 */
public class BasketTest {

    public static void main(String[] args) {

        Basket basket =new Basket();

        BasketProducerThread basketProducerThread =new BasketProducerThread(basket);

        BasketConsumerRunnable basketConsumerThread=new BasketConsumerRunnable(basket);

        basketProducerThread.start();

        basketConsumerThread.start();

    }
}

测试结果

第二种：

篮子：

package com.commons.commons.basket;

/**
 * @Author zhaomengxia
 * @create 2019/10/14 16:09
 */
public class Basket {

    private boolean isEmpty;

    public boolean isEmpty() {
        return isEmpty;
    }

    public void setEmpty(boolean empty) {
        isEmpty = empty;
    }
}

生产者

package com.commons.commons.basket;

/**
 * @Author zhaomengxia
 * @create 2019/10/14 16:09
 */
public class BasketProducerRunnable implements Runnable {


    private Basket basket;

    public BasketProducerRunnable(Basket backet) {
        super();
        this.basket = backet;
    }

    @Override
    public void run() {
        while (true) {
            //定义一个同步代码块
            synchronized (basket) {
                try {
                    if (!basket.isEmpty()) {
                        //线程等待状态
                        basket.wait();
                    }
                    System.out.println("生成！");
                    basket.setEmpty(false);
                    //通知在这个共享对象上等待的线程
                    basket.notify();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

消费者

package com.commons.commons.basket;

/**
 * @Author zhaomengxia
 * @create 2019/10/14 16:22
 */
public class BasketConsumerRunnable implements Runnable {


    private Basket basket;

    public BasketConsumerRunnable(Basket basket) {
        super();
        this.basket = basket;
    }

    @Override
    public void run() {
        while (true) {
            synchronized (basket) {
                try {
                    if (basket.isEmpty()) {

                        basket.wait();
                    }
                    System.out.println("消费！");
                    basket.setEmpty(true);
                    basket.notify();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

测试

package com.commons.commons.basket;

/**
 * @Author zhaomengxia
 * @create 2019/10/14 16:27
 */
public class BasketTest {

    public static void main(String[] args) {

        Basket backet=new Basket();

        Thread producer=new Thread(new BasketProducerRunnable(backet));

        Thread consumer=new Thread(new BasketConsumerRunnable(backet));
        producer.start();

        consumer.start();

    }
}

结果