java多线程生产者消费者

//Java Thread  producer customer
class ThreadTest
{
     public static void main(String[] args)
     {
         Q q=new Q();

         Producer p=new Producer(q);
         Customer c=new Customer(q);
         Thread t0=new Thread(p);
         Thread t1=new Thread(c);
         t0.start();
         t1.start();

         for(int i=0;i<50;i++)
         {
             if(i==25)
             {
                p.stop();
                c.stop();
             }

             System.out.println(Thread.currentThread().getName());
         }
     }
}

class Q
{
     String name="empty";
     String gender="empty";
     boolean isEmpty=true;

     public synchronized void Put(String name,String gender)
     {
        if (!isEmpty) {
            try {wait();} catch (Exception ex) {}
        }
        this.name = name;
        try {Thread.sleep(1);} catch (Exception ex) {}
        this.gender = gender;
        isEmpty = false;
        notify();
     }

     public synchronized void Get()
     {
         if(isEmpty)
         {
             try{wait();}catch(Exception ex){}
         }
         System.out.println("name:"+this.name+"__gender:"+this.gender);
         isEmpty=true;
         notify();
     }
}

class Producer implements Runnable
{
    Q q;
    boolean isStop=false;
    public void stop()
    {
        this.isStop=true;
    }
    public Producer(Q q)
    {
        this.q=q;
    }

    public void run() {
        int i = 0;
        while (!isStop) {
            if (i == 0) {
                q.Put("Tim", "male");

            } else {
                q.Put("Lian", "female");
            }
            i = (i + 1) % 2;
        }
    }
}

class Customer implements Runnable
{
    Q q;
    boolean isStop=false;
    public void stop()
    {
        this.isStop=true;
    }
    public Customer(Q q)
    {
        this.q=q;
    }
    public void run()
    {
        while(!isStop)
        {
            q.Get();
        }
    }
}



时间: 2024-10-11 22:53:22

java多线程生产者消费者的相关文章

java多线程 生产者消费者模式

package de.bvb; /** * 生产者消费者模式 * 通过 wait() 和 notify() 通信方法实现 * */ public class Test1 { public static void main(String[] args) { Godown godown = new Godown(50); for (int i = 0; i < 5; i++) { new ProducerThread(i * 10, godown).start(); new ConsumerThre

java 多线程-生产者消费者模式-管程法

生产者消费者模式管程法通过容器中介,将数据放入和取出 wait()导致当前线程等待,直到另一个线程调用该对象的notify()或notyfyAll()方法notify()唤醒正在等待对象监视器的单个线程,notifyAll()唤醒正在等待对象监视器的所有线程 public class tuble { public static void main(String[]args) { SynContainer container=new SynContainer(); new Productor(co

java 多线程生产者消费者

class Res { private String name; private int count = 1; private boolean flag; public synchronized void set(String name) { while (flag) { try { this.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } this.name = name + "--" + cou

java多线程 生产者消费者案例-虚假唤醒

package com.java.juc; public class TestProductAndConsumer { public static void main(String[] args) { Clerk clerk = new Clerk(); Produce produce = new Produce(clerk); Consumer consumer = new Consumer(clerk); new Thread(produce, "线程A").start(); ne

[JAVA 多线程] 生产者消费者实例

正好有人问,就直接将代码记录下来. 背景:有一个仓库存储货物,存在着生产者和消费者,设计一个可以并发的实现. 设计思路:设计一个仓库类,类中保存最大的容量限制和当前的count,类中包含生产和消费的方法,并且都是synchronized. 具体代码: package com.test.tiny; public class Store { private final int MAX_SIZE; //最大 private int count; // 当前 public Store(int n) {

Java多线程-生产者/消费者模式实现

单生产者与单消费者 示例: public class ProduceConsume { public static void main(String[] args) { String lock = new String(""); Produce produce = new Produce(lock); Consume consume = new Consume(lock); new Thread(() -> { while (true) { produce.setValue();

Java 多线程 生产者消费者问题

1 package producer; 2 3 public class SyncStack { 4 int index =0; 5 SteamedBun[] bunArr = new SteamedBun[6]; //栈里只能放6个元素 6 7 public synchronized void push(SteamedBun bun) 8 { 9 while(index >= bunArr.length) //栈满等待 10 { 11 bun.setIndex(bunArr.length -1

Java多线程--生产者与消费者问题

说明 Java中,线程之间的通信主要是由java.lang.Object类提供的wait.notify和notifyAll这3个方法来完成: ①对象的wait方法被调用后,线程进入对象的等待队列中,并释放对象锁,其它线程可以竞争使用此对象锁:sleep方法使得一个线程进入睡眠状态,但是线程所占有的资源并没有释放. ②当对象的notify方法被调用,该方法会从对象的等待队列中随机取出一个线程来唤醒:notifyAll是唤醒等待队列中所有线程,这些线程会与其它正在执行的线程共同竞争对象锁. ③wai

java多线程 生产消费者模型

[seriesposts sid=500] 下面的代码讲述了一个故事 一个面包生产铺里目前有30个面包,有三个人来买面包,第一个人要买50个,第二个要买20个,第三个要买30个. 第一个人不够,所以等着,让第二个买了.面包铺继续生产面包.有7个人在生产. package com.javaer.thread; public class CPMode { public static void main(String[] args) { Godown godown = new Godown(30);