线程间的通信

这里讲的是同步，是指多个线程通过synchronized关键字这种方式来实现线程间的通信。

案例：

生产者生成水果，如果水果没有被买走那么就不生产，处于等待状态，如果水果被消费者买走这时候消费者就会通知生产者，告诉他我们已经把水果买走了请重新生产。

消费者同理，如果水果已经生产出来那么就买走，买走了之后通知生产者水果已经没有了，请生产。

Java 线程发送通知 java线程间如何通信_同步代码块

注意:

1.线程间的通讯共享数据一定要有同步代码块 synchronized
2.一定要有wait和notify，而且二者一定是成对出现。
3.生产者和消费者的线程实现一定是在white(true)里面

第一种方式 继承 Thread

创建篮子:
package demo3;
//创建篮子
public class Basket {
    private boolean isEmpty; //是否为空

    public boolean isEmpty(){
        return isEmpty;
    }
    public void setEmpty(boolean empty){
        isEmpty = empty;
    }
}
创建生产者:
package demo3;
//创建生产者
public class Producer extends Thread {
    private Basket basket;
    public Producer(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(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
创建消费者:
package demo3;
//创建消费者
public class Consumer extends Thread {
    private Basket basket;
    public Consumer(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 demo3;
//测试类
public class Test {
    public static void main(String[] args) {
        Basket basket = new Basket();
        Producer producer = new Producer(basket);
        Consumer consumer = new Consumer(basket);

        //给一个休眠时间，以免太快
        producer.start();
        consumer.start();
    }
}

第二种方式 接口 Runnable

篮子写法不变：
package demo3;

public class Basket {
    private boolean isEmpty; //是否为空

    public boolean isEmpty(){
        return isEmpty;
    }
    public void setEmpty(boolean empty){
        isEmpty = empty;
    }
}
创建生产者：
package demo3;

public class Producer implements Runnable{
    private Basket basket;
    public Producer(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(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
创建消费者:
package demo3;

public class Consumer implements Runnable {
    private Basket basket;
    public Consumer(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 demo3;

public class Test {
    public static void main(String[] args) {
        Basket basket = new Basket();
        Producer producer = new Producer(basket);
        Consumer consumer = new Consumer(basket);

        Thread t = new Thread(producer);
        Thread t1 = new Thread(consumer);
        //给一个休眠时间，以免太快
        t.start();
        t1.start();
    }
}