生产者和消费者

生产者和消费者:当生产者在生产时,消费者等待。生产者生产完毕,唤醒消费者,消费者消费。消费者消费时,生产者等待,消费者消费完毕,唤醒生产者生产。实现代码如下:

//生产者和消费者 class Info { private String str1="中国"; private String str2="武汉"; public boolean flag=false; public synchronized void setStr1(String str1){ //set方法 this.str1=str1; } public synchronized void setStr2(String str2){ //set方法 this.str2 = str2; } public synchronized String getStr1(){ //get方法 return this.str1; } public synchronized String getStr2(){ //get方法 return this.str2; } //统一的set方法,进行一次设置 public synchronized void set(String str1,String str2){ if(flag){ try{ super.wait(); //不可生产,等待 }catch(InterruptedException e){ e.printStackTrace(); } } this.setStr1(str1); this.setStr2(str2); System.out.println("设置完成"); flag=true; //修改标志位 try{ Thread.sleep(300); //在唤醒线程之前先休息300mm } catch(InterruptedException e){ e.printStackTrace(); } super.notify(); //唤醒线程 } //统一的get方法,进行一次资源取出 public synchronized void get(){ if(!flag){ try{ super.wait(); }catch(InterruptedException e){ e.printStackTrace(); } } System.out.println("取出"+this.getStr1()+"----->"+this.getStr2()); flag=false; //修改标志位 try{ Thread.sleep(300); //在唤醒线程之前先休息300mm } catch(InterruptedException e){ e.printStackTrace(); } super.notify(); } } class Producter implements Runnable { private Info info = null; public Producter(Info info){ this.info = info; } private boolean flag2=true; public void run(){ for(int i=0;i<50;i++){ if(flag2){ info.set("中国","武汉"); flag2=false; }else{ info.set("美国","纽约"); flag2=true; } } } } class Consumer implements Runnable { private Info info=null; public Consumer(Info info){ this.info = info; } public void run(){ for(int i=0;i<50;i++){ this.info.get(); } } } public class Demo26 { public static void main(String args[]){ Info info = new Info(); Producter p = new Producter(info); Consumer c = new Consumer(info); Thread tp = new Thread(p); Thread tc = new Thread(c); tp.start(); tc.start(); } }

这这里使用了notify进行唤醒,关于notify的使用,通过查阅API其定义是:“唤醒在此对象监视器上等待的单个线程。如果所有线程都在此对象上等待,则会选择唤醒其中一个线程。选择是任意性的,并在对实现做出决定时发生。线程通过调用其中一个 wait 方法,在对象的监视器上等待。 ”结合以上代码不难理解,notify在Info类内进行的调用,Info产生的对象是所有线程共同监听的对象。本程序中定义了两个线程,此两个线程共同监听互相唤醒。

生产者和消费的定义不难理解,关键问题是对代码的理解,

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
在Java中,"生产者-消费者"(Producer-Consumer)模式是一种经典的设计模式,用于解决多线程环境中的同步问题。它定义了两个角色,即生产者(Producer)和消费者(Consumer),它们分别负责创建数据(产品)和消费数据。 **1. 生产者(Producer):** 生产者通常在自己的线程中不断产生新的对象,并将这些对象添加到一个共享的队列(如`BlockingQueue`、`ArrayBlockingQueue`等)中。生产者需要处理可能的数据溢出(队列已满)和资源竞争(队列为空)。 **2. 消费者(Consumer):** 消费者从队列中取出数据并进行处理,消耗掉生产者产生的对象。同样,消费者需要处理可能的数据饥饿(队列空)和资源竞争(队列满)。 **3. 同步机制:** 为了确保生产者消费者之间的同步,Java提供了`synchronized`关键字或`Semaphore`、`CountDownLatch`、`CyclicBarrier`等并发工具。使用这些工具可以控制访问队列的权限,避免数据不一致或死锁。 **4. 示例代码:** 下面是一个简单的`BlockingQueue`实现的生产者消费者示例: ```java import java.util.concurrent.*; public class ProducerConsumer { private final BlockingQueue<String> queue = new LinkedBlockingQueue<>(10); private final Thread producer; private final Thread consumer; public ProducerConsumer() { producer = new Thread(() -> produceData()); consumer = new Thread(() -> consumeData()); producer.start(); consumer.start(); } private void produceData() { while (true) { synchronized (queue) { if (queue.isEmpty()) { try { queue.wait(); // 队列空时等待 } catch (InterruptedException e) { e.printStackTrace(); } } String data = generateData(); // 生产数据 queue.offer(data); // 添加到队列 System.out.println("Produced: " + data); queue.notify(); // 唤醒消费者 } } } private void consumeData() { while (true) { synchronized (queue) { if (queue.isEmpty()) { try { queue.wait(); // 队列空时等待 } catch (InterruptedException e) { e.printStackTrace(); } } String data = queue.take(); // 从队列获取数据 System.out.println("Consumed: " + data); } } } private String generateData() { // 实现数据生成逻辑 return "Data " + UUID.randomUUID().toString(); } public static void main(String[] args) { new ProducerConsumer(); } } ```
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值