java实现生产者消费者模型

实现一个生产者/消费者模型，其中：

生产者生产10个随机的整数供消费者使用（随机数可以通过new Random().nextInt()获得）
消费者依次消费这10个随机的整数
标准输出应该得到这样的结果：

Producing 42
Consuming 42
Producing -1
Consuming -1
…
Producing 10086
Consuming 10086
Producing -12345678
Consuming -12345678

使用wait，notify方法

分析首先需要一个容器来存储，其次需要一个lock，具体代码实现方式
建Container类当做容器；

import java.util.Optional;

public class Container {
    public static Optional<Integer> value= Optional.empty();
    //添加getter setter 来访问容器的值

    public static Optional<Integer> getValue() {
        return value;
    }

    public static void setValue(Optional<Integer> value) {
        Container.value = value;
    }
}

然后把主函数两个变量容器和锁造出来

public class Boss {
    Container container=new Container();
    Object lock =new Object();
}

构造生产者

注意，因为生产者和消费者最终都是要多线程的，所以这里必须要继承Thread类，重写run方法
如果你直接创造一个produce方法是不行的

import java.util.Optional;
import java.util.Random;

public class Producer extends Thread {
    Container container;
    Object lock;

    public Producer(Container container, Object lock) {
        this.container = container;
        this.lock = lock;
    }

    @Override
    public void run() {
        synchronized (lock) {
            while (container.getValue().isPresent()) {
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            Integer r = new Random().nextInt();
            System.out.println("Producing" + r);
            container.setValue(Optional.of(r));
            lock.notify();
        }
    }
}

这个

container.setValue(Optional.of(r));

这个方法注意一下，调用了set方法把r的值传递进去，同时还调用了Optional.of()方法；
同样的方式，将消费者构造出来

import java.util.Optional;

public class Consumer extends Thread {
    Container container;
    Object lock;

    public Consumer(Container container, Object lock) {
        this.container = container;
        this.lock = lock;
    }

    @Override
    public void run() {
        synchronized (lock) {
            while (!container.getValue().isPresent()) {
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("Producing" + container.getValue().get());
            container.setValue(Optional.empty());
            lock.notify();
        }
    }
}

这两行代码需要注意

 System.out.println("Producing"+container.getValue().get());
 container.setValue(Optional.empty());

最后写完主函数

public class Boss {

   public static void main(String[] args) {
       Container container=new Container();
       Object lock =new Object();

   Producer producer=new Producer(container,lock);
   Consumer consumer=new Consumer(container,lock);
   producer.start();
   consumer.start();
}}

记住方法调用一定要在方法里，我这里又忘了写psvm，结果producer.start()报红again·····
最后把循环加到producer和consumer里


跑一下试试

最后你在调用start方法时候，实际上实在调用run方法！