Java学习(7):同步问题之生产者与消费者的问题

生产者生产馒头,消费者消费馒头。一个篮子,生产者往篮子中放馒头,消费者从篮子中取馒头。

/**
 * 这是一个篮子类
 *
 * @author xcx
 * @time 2017年7月21日上午10:01:32
 */
public class Basket {
    // 篮子里最多可以装10个馒头
    private final int Max_Numbers_StreamedBread = 10;
    SteamedBread[] sbBreads = new SteamedBread[Max_Numbers_StreamedBread];
    // 用来标记篮子中馒头的数量
    private int index = 0;

    // 向篮子中放馒头的方法
    public synchronized void push(SteamedBread sbBread) {
        while (index >= Max_Numbers_StreamedBread) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.notify();
        sbBreads[index] = sbBread;
        index++;

    }

    // 从篮子中拿馒头的方法
    public synchronized SteamedBread pop() {
        while (index <= 0) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return null;
        }
        this.notify();
        index--;
        return sbBreads[index];

    }

}
/**
 *消费者类
 *@author xcx
 *@time 2017年7月21日上午10:23:53
 */
public class Consumer implements Runnable {
    Basket b = new Basket();
    private SteamedBread steamedBread;
    public Consumer(Basket b){
        this.b = b;
    }

    @Override
    public void run() {
        for(int i=0;i<20;i++){
            steamedBread = b.pop();
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if(steamedBread == null){
            }else{
                System.out.println("消费"+steamedBread);
            }

        }

    }

}
/**
 * 这是一个生产者类
 *
 * @author xcx
 * @time 2017年7月21日上午10:16:25
 */
public class Producer implements Runnable {
    private Basket b = new Basket();
    public Producer(Basket b){
        this.b = b;
    }
    @Override
    public void run() {
        for(int i=0;i<20;i++){
            SteamedBread sBread = new SteamedBread(i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("生产了第"+i+"个馒头");
            b.push(sBread);
        }
    }
}
/**
 *this is a class about SteamedBread
 *@author xcx
 *@time 2017年7月21日上午9:59:16
 */
public class SteamedBread {
    private int i;
    public SteamedBread(int i){
        this.i = i;
    }

    @Override
    public String toString() {
        return "第"+i+"个馒头";
    }

}
/**
 *同步线程测试类
 *@author xcx
 *@time 2017年7月21日上午10:44:10
 */
public class Test {

    public static void main(String[] args) {
        //创建篮子的对象
        Basket basket = new Basket();
        //创建生产者线程和消费者线程
        Producer producer = new Producer(basket);
        Consumer consumer = new Consumer(basket);

        Thread t1 = new Thread(producer);
        Thread t2 = new Thread(consumer);

        t1.start();
        t2.start();

    }

}
时间: 2024-10-01 02:22:01

Java学习(7):同步问题之生产者与消费者的问题的相关文章

并发无锁队列学习之二【单生产者单消费者】

1.前言 最近工作比较忙,加班较多,每天晚上回到家10点多了.我不知道自己还能坚持多久,既然选择了就要做到最好.写博客的少了.总觉得少了点什么,需要继续学习.今天继续上个开篇写,介绍单生产者单消费者模型的队列.根据写入队列的内容是定长还是变长,分为单生产者单消费者定长队列和单生产者单消费者变长队列两种.单生产者单消费者模型的队列操作过程是不需要进行加锁的.生产者通过写索引控制入队操作,消费者通过读索引控制出队列操作.二者相互之间对索引是独享,不存在竞争关系.如下图所示: 2.单生产者单消费者定长

JAVA学习笔记(四十二)-生产者消费者模型

wait().notify() /* * wait().notify() * * 1.两个方法都只能在synchronized代码块中执行,因为要对持有锁的线程操作,只有同步中才有锁 * 2.两个方法在操作同步中的线程时,必须要标识所操作线程持有的对象锁 * 3.等待和唤醒必须是同一个对象锁 */ public class Test05 { public static void main(String[] args) { MyThread3 mt=new MyThread3(); Thread

在程序中利用信号量同步来模拟生产者与消费者

信号量同步的概念: 一组并发进程进行相互合作.相互等待,使得各进程按一定的顺序执行的过程称为进程间的同步. customer.c product.c 运行生产者 运行消费者:

Java 学习————多线程同步

public class Tongywo { public static void main(String[] args) { // TODO Auto-generated method stub Shangdian0 sd=new Shangdian0(100); Goumai0 no1=new Goumai0(70, sd, "No.1"); Goumai0 no2=new Goumai0(80, sd, "No.2"); no1.start(); no2.st

JAVA——利用wait和notify实现生产者和消费者

经典的消费者和生产者的的实现: 注意事项: 1:在循环里面用wait(),因为当线程获得了锁,但是有可能还没有满足其他条件: 2:公用的缓冲池要用锁机制: 1 package demo; 2 3 import java.util.Vector; 4 5 public class Main { 6 7 public static void main(String[] args) { 8 Vector<Integer> pool=new Vector<Integer>(); 9 Pro

Java多线程虚假唤醒问题(生产者和消费者关系)

何为虚假唤醒: 当一个条件满足时,很多线程都被唤醒了,但是只有其中部分是有用的唤醒,其它的唤醒都是无用功:比如买货:如果商品本来没有货物,突然进了一件商品,这是所有的线程都被唤醒了,但是只能一个人买,所以其他人都是假唤醒,获取不到对象的锁: 避免虚假唤醒: 避免虚假唤醒的示例:这里使用了 Lambda 表达式 package com.jia.pc; public class A { public static void main(String[] args) { Data data = new

Android(java)学习笔记71:生产者和消费者之等待唤醒机制

首先我们根据梳理我们之前Android(java)学习笔记70中关于生产者和消费者程序思路: 下面我们就要重点介绍这个等待唤醒机制: 第一步:还是先通过代码体现出等待唤醒机制 package cn.itcast_05; /* * 分析: * 资源类:Student * 设置学生数据:SetThread(生产者) * 获取学生数据:GetThread(消费者) * 测试类:StudentDemo * * 问题1:按照思路写代码,发现数据每次都是:null---0 * 原因:我们在每个线程中都创建了

Java---19---多线程:生产者和消费者

生产者和消费者问题是多线程通信的经典问题.这类问题描述了这样一种情况:假设有一个仓库,用来存储产品,有生产者负责生产产品,有消费者负责消费.生产者生产的产品存放在仓库之中,消费者从仓库之中取出产品.显然这是一个同步问题,生产者和消费者共享同一资源,并且生产者和消费者之间彼此依赖,互为条件向前推进.那么,该如何编写代码来实现呢? class Resource { private String name; private String sex; private boolean flag = fals

信号量生产者和消费者模型

使用信号量完成线程间同步,模拟生产者,消费者问题.                                         [sem_product_consumer.c] 思路分析: 规定: 如果□中有数据,生产者不能生产,只能阻塞. 如果□中没有数据,消费者不能消费,只能等待数据. 定义两个信号量:S满 = 0, S空 = 1 (S满代表满格的信号量,S空表示空格的信号量,程序起始,格子一定为空) -------------------------------------------