Java中线程通信

线程通信是通过Object类中的方法来实现的

通过wait()  notify()   notifyAll()  来实现

方法名	作  用
final void wait()	表示线程一直等待，直到其它线程通知
void wait(long timeout)	线程等待指定毫秒参数的时间
final void wait(long timeout,int nanos)	线程等待指定毫秒、微妙的时间
final void notify()	唤醒一个处于等待状态的线程
final void notifyAll()	唤醒同一个对象上所有调用wait()方法的线程，优先级别高的线程优先运行

注意：在进行线程同步过程中生产者消费者要使用同一把锁 

将product设为同步监视器，将生产者和消费者同步起来

 定义一个产品类：实现产品的基本性质以及“中转站”中是否有商品

/**
 * 商品类
 */
public class Product {
    private String name;//名称  馒头 米饭
    private String color;//黄色白色
    boolean falg = false;//默认没有商品

    public Product() {
    }

    public Product(String name, String color) {
        this.name = name;
        this.color = color;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    @Override
    public String toString() {
        return "Product{" +
                "name='" + name + '\'' +
                ", color='" + color + '\'' +
                '}';
    }
}

定义生产者线程：通过将product设为同步监视器，运用wait（）判断是否有生产的商品，

如果有生产的商品，停止生产：释放cpu，释放锁。

没有生产的商品，进行生产商品。

并进行更改中转站的状态，更改为有生产的商品

使用notify（）唤醒在该同步监视器上面的线程

package communicate3;

import java.sql.Struct;

/**
 * 生产者线程
 */
public class ProduceRunnable implements Runnable
{
    private Product product;

    public ProduceRunnable() {
    }

    public ProduceRunnable(Product product) {
        this.product = product;
    }

    public void setProduct(Product product) {
        this.product = product;
    }

    @Override
    public void run() {
        int i=0;
        while (true) {
            //如果有商品就等待

            //如果没有商品就等待
            synchronized (product) {
                if (product.falg) {
                    try {
                        product.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                }
                if (i % 2 == 0) {
                    product.setName("馒头");//这两个语句不能分开
                    try {
                        Thread.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    product.setColor("白色");
                }else  {

                    product.setName("玉米饼");
                    try {
                        Thread.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    product.setColor("黄色");
                }
            }

            System.out.println("生产者生产一个"+product.getName()+product.getColor());
            i++;
            //改变商品有无的状态
            product.falg = true;
            //通知消费
            product.notifyAll();//唤醒所有等待的线程

        }
    }
}

定义消费者线程

public class ConsumeRunnble implements Runnable {
    private Product product;

    public ConsumeRunnble(Product product) {
        this.product = product;
    }

    public ConsumeRunnble() {
    }

    public void setProduct(Product product) {
        this.product = product;
    }

    @Override
    public void run() {
        //对生产者和消费者的锁是统一把锁
        while (true) {
            synchronized (product) {
                //如果没有商品就等待
                if (!product.falg) {
                    try {
                        product.wait();//让出了cpu也让出了锁
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                //如果有商品就消费商品
                System.out.println("消费者消费一个产品:"+product.getColor()+product.getName());

                //改变商品的有无状态
                product.falg = false;

                //通知生产者生产
                product.notify();//随机唤醒一个处于等待的线程
            }

        }
    }
}

这里运用flag判断是否有商品，没有商品就用wait方法阻塞消费者线程并释放同步监视器

有商品就进行消费，消费结束，改变flag状态，唤醒等待的线程。 

进行测试

 public static void main(String[] args) {
        Product product = new Product();
        //创建线程对象
        Runnable runnable1 = new ProduceRunnable(product);
        Thread thread1 = new Thread(runnable1);
        ConsumeRunnble runnable2 = new ConsumeRunnble();
        runnable2.setProduct(product);
        Thread thread2 = new Thread(runnable2);
        //启动线程
        thread1.start();
        thread2.start();

    }