Java生产者和消费者

本文介绍了一个使用Java实现的仓库管理程序,通过生产者-消费者模型演示了多线程环境下如何利用synchronized关键字配合wait()、notify()等方法来实现线程间的同步控制。程序能够确保在多线程并发情况下仓库不会出现超容或空取的情况。
/**
 * Created by wjz on 2017/3/12.
 */
public class Store {
    private final int MAX_SIZE;             //仓库的最大容量
    private int count;                      //当前的货物数量
    public Store(int n) {
        MAX_SIZE = n;
        count = 0;
    }
    //往仓库加货物的方法
    public synchronized void add() {
        while (count >= MAX_SIZE) {
            System.out.println("已经满了");
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        count++;
        //打印当前仓库的货物数量
        System.out.println(Thread.currentThread().toString() + "put" + count);
        this.notifyAll();
    }

    //从仓库中拿走货物的方法
    public synchronized void remove() {
        while(count <= 0) {
            System.out.println("空了");
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(Thread.currentThread().toString() + "get" + count);
        count--;
        //仓库还没装满,通知生产者添加货物
        this.notify();
    }

    public static void main(String[] args) {
        Store s = new Store(5);
        Thread pro = new Producer(s);
        Thread con = new Consumer(s);
        Thread pro2 = new Producer(s);
        Thread con2 = new Consumer(s);
        pro.setName("producer");
        con.setName("consumer");
        pro2.setName("producer2");
        con2.setName("consumer2");

        pro.start();
        pro2.start();
        con.start();
        con2.start();
    }
}

class Producer extends Thread {
    private Store s;
    public Producer(Store s) {
        this.s = s;
    }

    @Override
    public void run() {
        while(true) {
            s.add();
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

class Consumer extends Thread {
    private Store s;
    public Consumer(Store s) {
        this.s = s;
    }

    @Override
    public void run() {
        while (true) {
            s.remove();
            try {
                Thread.sleep(1500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
其中wait()、notify()、notifyAll()都是native方法,需要加上synchronized关键字。
### Java生产者消费者问题的实现方式 在Java中,生产者-消费者问题是通过多线程同步机制解决的经典案例之一。该模式利用共享资源(如队列),其中生产者向队列添加项而消费者从中移除项。 #### 使用 `wait()` `notifyAll()` 一种常见的方法是采用`wait()/notifyAll()`机制来协调生产消费过程中的线程间通信[^3]。下面是一个简化版的例子: ```java public class ProducerConsumerExample { static class Basket { private final List<Integer> list = new ArrayList<>(); private final int LIMIT = 10; public synchronized void put(int value) throws InterruptedException { while (list.size() == LIMIT) { wait(); } list.add(value); notifyAll(); } public synchronized Integer get() throws InterruptedException { while (list.isEmpty()) { wait(); } Integer value = list.remove(0); notifyAll(); return value; } } static class Producer implements Runnable { private final Basket basket; public Producer(Basket bskt) { this.basket = bskt; } @Override public void run() { Random random = new Random(); for (int i = 0; ; i++) { try { Thread.sleep(random.nextInt(500)); basket.put(i); System.out.println("Produced:" + i); } catch (InterruptedException e) { break; } } } } static class Consumer implements Runnable { private final Basket basket; public Consumer(Basket bskt) { this.basket = bskt; } @Override public void run() { for (int i = 0; ; i++) { try { Thread.sleep(2000); Integer consumedValue = basket.get(); System.out.println("Consumed:" + consumedValue); } catch (InterruptedException e) { break; } } } } public static void main(String[] args) { Basket sharedBasket = new Basket(); ExecutorService executorService = Executors.newFixedThreadPool(4); executorService.execute(new Producer(sharedBasket)); executorService.execute(new Consumer(sharedBasket)); // Shutdown after some time to prevent infinite loop. ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1); scheduler.schedule(() -> executorService.shutdown(), 1, TimeUnit.MINUTES); } } ``` 此程序展示了如何创建一个简单的生产者-消费者场景,在这里使用了阻塞队列的概念以及`wait()``notifyAll()`来进行线程间的协作。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值