生产者消费者问题(notify和wait)

最新推荐文章于 2020-12-09 16:19:50 发布

重生之我是一名程序员

最新推荐文章于 2020-12-09 16:19:50 发布

阅读量3.8k

点赞数 1

分类专栏： thread

thread 专栏收录该内容

16 篇文章 0 订阅

订阅专栏

使用notify和wait机制实现生产者和消费者

设计:

产品: Product类
产品库: ProductRepository类
生产者线程
消费者线程

Product.java:

public class Product {

    private String name;
    private long productNo;

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

    public String getName() {
        return name;
    }

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

    public long getProductNo() {
        return productNo;
    }

    public void setProductNo(long productNo) {
        this.productNo = productNo;
    }

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

ProductRepository.java:

public class ProductRepository {

    private Vector<Product> products = new Vector<>();
    private static final int MAX_NUM = 10;

    public void produce(){
        synchronized (products){
            if (products.size() == MAX_NUM){ //如果仓库已经满了
                try {
                    wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            //products.size() < MAX_NUM 如果仓库还没有满
            Product product = new Product("包子", System.currentTimeMillis());
            products.add(product);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+ " 生产了： "+ product+" ,产品仓库当前数量： "+ products.size());
            //通知等待的消费者来消费
            notify();
        }
    }


    public void consume(){
        synchronized (products){
            if (products.size() == 0){ //产品仓库空了，等待生产者生产
                try {
                    wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            Product product = products.firstElement();
            products.remove(0);
            System.out.println(Thread.currentThread().getName()+ " 消费了： " + product+" ,产品仓库当前数量： "+ products.size());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //通知生产者生产
            notify();
        }
    }

}

Consumer.java:

public class Consumer implements Runnable {

    private ProductRepository repository;

    public Consumer(ProductRepository repository) {
        this.repository = repository;
    }

    @Override
    public void run() {
        while (true){
            repository.consume();
        }
    }
}

Producer.java:

public class Producer implements Runnable {

    private ProductRepository repository;

    public Producer(ProductRepository repository) {
        this.repository = repository;
    }

    @Override
    public void run() {
        while (true){
            repository.produce();
        }
    }
}

一个生产者，一个消费者

测试类:

public class ProductorConsumerTest {


    /**
     * 一个生产者，一个消费者
     * @throws InterruptedException
     */
    public static void oneProducerAndOneConsumer() throws InterruptedException {
        ProductRepository repository = new ProductRepository();
        Consumer consumer = new Consumer(repository);
        Producer producer = new Producer(repository);
        Thread t1 = new Thread(producer,"producer-A");
        Thread t2 = new Thread(consumer,"consumer-B");
        t1.start();
        t2.start();
        t1.join();
        t2.join(); //join(): 主线程等待t1线程和禾t2线程都执行完
    }
    public static void main(String[] args) throws InterruptedException {
           oneProducerAndOneConsumer();
    }
}

结果:

Exception in thread "producer-A" java.lang.IllegalMonitorStateException
    at java.lang.Object.notify(Native Method)
    at com.gml.pinlor.thread.pcproblem.ProductRepository.produce(ProductRepository.java:33)
    at com.gml.pinlor.thread.pcproblem.Producer.run(Producer.java:17)
    at java.lang.Thread.run(Thread.java:745)
producer-A 生产了： Product{name='包子', productNo=1521786358450} ,产品仓库当前数量： 1
consumer-B 消费了： Product{name='包子', productNo=1521786358450} ,产品仓库当前数量： 0

java.lang.IllegalMonitorStateException是什么鬼？在API中是这么描述的:

Thrown to indicate that a thread has attempted to wait on an object’s monitor or to notify other threads waiting on an object’s monitor without owning the specified monitor(一个线程尝试等待一个对象的监视器，或者去通知其他正在等待对象监视器线程，却没有指明一个具体的监视器，才会抛出这个异常)

原来是将synchronized监视到products对象上了，但调用wait和notify方法却不是products对象,将ProductRepository.java换成:

public class ProductRepository {

    private Vector<Product> products = new Vector<>();
    private static final int MAX_NUM = 10;

    public void produce(){
        synchronized (products){
            if (products.size() == MAX_NUM){ //如果仓库已经满了
                try {
                    products.wait();      //让products等待！！！
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            //products.size() < MAX_NUM 如果仓库还没有满
            Product product = new Product("包子", System.currentTimeMillis());
            products.add(product);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+ " 生产了： "+ product+" ,产品仓库当前数量： "+ products.size());
            //通知等待的消费者来消费
            products.notify();
//            products.notifyAll();
        }
    }


    public void consume(){
        synchronized (products){
            if (products.size() == 0){ //产品仓库空了，等待生产者生产
                try {
                    products.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            Product product = products.firstElement();
            products.remove(0);
            System.out.println(Thread.currentThread().getName()+ " 消费了： " + product+" ,产品仓库当前数量： "+ products.size());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //通知生产者生产
            products.notify();
//            products.notifyAll();
        }
    }

}

结果:

producer-A 生产了： Product{name='包子', productNo=1521786975941} ,产品仓库当前数量： 1
consumer-B 消费了： Product{name='包子', productNo=1521786975941} ,产品仓库当前数量： 0
producer-A 生产了： Product{name='包子', productNo=1521786978944} ,产品仓库当前数量： 1
producer-A 生产了： Product{name='包子', productNo=1521786979944} ,产品仓库当前数量： 2
producer-A 生产了： Product{name='包子', productNo=1521786980944} ,产品仓库当前数量： 3
producer-A 生产了： Product{name='包子', productNo=1521786981945} ,产品仓库当前数量： 4
producer-A 生产了： Product{name='包子', productNo=1521786982945} ,产品仓库当前数量： 5
consumer-B 消费了： Product{name='包子', productNo=1521786978944} ,产品仓库当前数量： 4
consumer-B 消费了： Product{name='包子', productNo=1521786979944} ,产品仓库当前数量： 3

一个生产者，多个消费者

只需要在ProductRepository中将produce方法中products.notify()方法换成products.notifyAll()方法即可

public class ProductRepository {

    private Vector<Product> products = new Vector<>();
    private static final int MAX_NUM = 10;

    public void produce(){
        synchronized (products){
            if (products.size() == MAX_NUM){ //如果仓库已经满了
                try {
                    products.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            //products.size() < MAX_NUM 如果仓库还没有满
            Product product = new Product("包子", System.currentTimeMillis());
            products.add(product);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+ " 生产了： "+ product+" ,产品仓库当前数量： "+ products.size());
            //通知等待的消费者来消费
//            products.notify();
            products.notifyAll();
        }
    }


    public void consume(){
        synchronized (products){
            if (products.size() == 0){ //产品仓库空了，等待生产者生产
                try {
                    products.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            Product product = products.firstElement();
            products.remove(0);
            System.out.println(Thread.currentThread().getName()+ " 消费了： " + product+" ,产品仓库当前数量： "+ products.size());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //通知生产者生产
            products.notify();
//            products.notifyAll();
        }
    }
}

测试:

public class ProductorConsumerTest {

    /**
     * 一个生产者，多个消费者
     * @throws InterruptedException
     */
    public static void oneProducerAndMoreConsumer() throws InterruptedException {
        ProductRepository repository = new ProductRepository();
        Consumer consumer = new Consumer(repository);
        Consumer consumer2 = new Consumer(repository);
        Producer producer = new Producer(repository);
        Thread t1 = new Thread(producer,"producer-A");
        Thread t2 = new Thread(consumer,"consumer-B");
        Thread t3 = new Thread(consumer,"consumer-C");
        t1.start();
        t2.start();
        t3.start();
        t1.join();
        t2.join();
        t3.join();
    }
    public static void main(String[] args) throws InterruptedException {
 //        oneProducerAndOneConsumer();
         oneProducerAndMoreConsumer();
 //        moreProducerAndMoreConsumer();
     }
}

结果:

producer-A 生产了： Product{name='包子', productNo=1521787226868} ,产品仓库当前数量： 1
producer-A 生产了： Product{name='包子', productNo=1521787227868} ,产品仓库当前数量： 2
producer-A 生产了： Product{name='包子', productNo=1521787228868} ,产品仓库当前数量： 3
producer-A 生产了： Product{name='包子', productNo=1521787229868} ,产品仓库当前数量： 4
producer-A 生产了： Product{name='包子', productNo=1521787230868} ,产品仓库当前数量： 5
producer-A 生产了： Product{name='包子', productNo=1521787231868} ,产品仓库当前数量： 6
producer-A 生产了： Product{name='包子', productNo=1521787232868} ,产品仓库当前数量： 7
producer-A 生产了： Product{name='包子', productNo=1521787233868} ,产品仓库当前数量： 8
producer-A 生产了： Product{name='包子', productNo=1521787234868} ,产品仓库当前数量： 9
producer-A 生产了： Product{name='包子', productNo=1521787235868} ,产品仓库当前数量： 10
consumer-C 消费了： Product{name='包子', productNo=1521787226868} ,产品仓库当前数量： 9
consumer-C 消费了： Product{name='包子', productNo=1521787227868} ,产品仓库当前数量： 8
consumer-B 消费了： Product{name='包子', productNo=1521787228868} ,产品仓库当前数量： 7
consumer-C 消费了： Product{name='包子', productNo=1521787229868} ,产品仓库当前数量： 6
consumer-C 消费了： Product{name='包子', productNo=1521787230868} ,产品仓库当前数量： 5
producer-A 生产了： Product{name='包子', productNo=1521787246869} ,产品仓库当前数量： 6

多个生产者，多个消费者

同样只需要修改ProductRepository中的consumer方法中的products.notity()为products.notifyAll(),通知所有的生产者

public class ProductRepository {

    private Vector<Product> products = new Vector<>();
    private static final int MAX_NUM = 10;

    public void produce(){
        synchronized (products){
            if (products.size() == MAX_NUM){ //如果仓库已经满了
                try {
                    products.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            //products.size() < MAX_NUM 如果仓库还没有满
            Product product = new Product("包子", System.currentTimeMillis());
            products.add(product);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+ " 生产了： "+ product+" ,产品仓库当前数量： "+ products.size());
            //通知等待的消费者来消费
//            products.notify();
            products.notifyAll();
        }
    }


    public void consume(){
        synchronized (products){
            if (products.size() == 0){ //产品仓库空了，等待生产者生产
                try {
                    products.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            Product product = products.firstElement();
            products.remove(0);
            System.out.println(Thread.currentThread().getName()+ " 消费了： " + product+" ,产品仓库当前数量： "+ products.size());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //通知生产者生产
//            products.notify();
            products.notifyAll();
        }
    }

}

测试:

public class ProductorConsumerTest {

    /**
     * 多个生产者，多个消费者
     * @throws InterruptedException
     */
    public static void moreProducerAndMoreConsumer() throws InterruptedException {
        ProductRepository repository = new ProductRepository();
        Consumer consumer = new Consumer(repository);
        Consumer consumer1 = new Consumer(repository);
        Producer producer = new Producer(repository);
        Producer producer1 = new Producer(repository);
        Thread t1 = new Thread(producer,"producer-A");
        Thread t2 = new Thread(consumer,"consumer-B");
        Thread t3 = new Thread(consumer1,"consumer-C");
        Thread t4 = new Thread(producer1,"producer-D");
        t1.start();
        t4.start();
        t2.start();
        t3.start();

        t1.join();
        t4.join();
        t2.join();
        t3.join();
    }

    public static void main(String[] args) throws InterruptedException {
       // oneProducerAndOneConsumer();
        // oneProducerAndMoreConsumer();
       moreProducerAndMoreConsumer();
    }
}

结果:

producer-A 生产了： Product{name='包子', productNo=1521787607751} ,产品仓库当前数量： 1
producer-A 生产了： Product{name='包子', productNo=1521787608752} ,产品仓库当前数量： 2
producer-A 生产了： Product{name='包子', productNo=1521787609752} ,产品仓库当前数量： 3
producer-A 生产了： Product{name='包子', productNo=1521787610752} ,产品仓库当前数量： 4
producer-A 生产了： Product{name='包子', productNo=1521787611753} ,产品仓库当前数量： 5
producer-A 生产了： Product{name='包子', productNo=1521787612753} ,产品仓库当前数量： 6
producer-A 生产了： Product{name='包子', productNo=1521787613753} ,产品仓库当前数量： 7
producer-A 生产了： Product{name='包子', productNo=1521787614753} ,产品仓库当前数量： 8
producer-D 生产了： Product{name='包子', productNo=1521787615753} ,产品仓库当前数量： 9
producer-D 生产了： Product{name='包子', productNo=1521787616753} ,产品仓库当前数量： 10
consumer-C 消费了： Product{name='包子', productNo=1521787607751} ,产品仓库当前数量： 9
consumer-B 消费了： Product{name='包子', productNo=1521787608752} ,产品仓库当前数量： 8
consumer-B 消费了： Product{name='包子', productNo=1521787609752} ,产品仓库当前数量： 7
consumer-B 消费了： Product{name='包子', productNo=1521787610752} ,产品仓库当前数量： 6
consumer-C 消费了： Product{name='包子', productNo=1521787611753} ,产品仓库当前数量： 5
consumer-C 消费了： Product{name='包子', productNo=1521787612753} ,产品仓库当前数量： 4
consumer-C 消费了： Product{name='包子', productNo=1521787613753} ,产品仓库当前数量： 3

重生之我是一名程序员

关注

1
点赞
踩
7

收藏

觉得还不错? 一键收藏
2
评论
生产者消费者问题(notify和wait)

使用notify和wait机制实现生产者和消费者设计:产品: Product类产品库: ProductRepository类生产者线程消费者线程Product.java: public class Product { private String name; private long productNo; public Product(S...
复制链接

扫一扫