java 生产者消费者

原创 2015年11月18日 16:26:14

共享数据的访问都要放在锁中进行。


1 synchronized方法:

public class ProduceConsumer {

public static void main(String[] args) {
Myqueue queue = new Myqueue();

Producer p1 = new Producer(queue);
Producer p2 = new Producer(queue);
Producer p3 = new Producer(queue);
Producer p4 = new Producer(queue);

Consumer c1 = new Consumer(queue);
Consumer c2 = new Consumer(queue);

new Thread(p1).start();
new Thread(p2).start();
new Thread(p3).start();
new Thread(p4).start();
new Thread(c1).start();
new Thread(c2).start();
}
}

class Myqueue {
private LinkedList<String> list;
private int maxSize = 10;
private int count = 0;
private int index = 0;

public Myqueue() {
list = new LinkedList<String>();
}

public Myqueue(int max) {
this();
maxSize = max;
}

public synchronized void put(String str) {
if (!this.isFull()) {
list.addLast(str + "--------编号" + index);

try {
Thread.sleep(500);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "生产者:  "
+ str + "+++++编号" + index);
count++;
index++;
this.notifyAll();
}
if (this.isFull()) {               //必须判断
try {
this.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}

public synchronized void get() {
if (!this.isEmpty()) {
try {
Thread.sleep(500);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "消费者: "
+ list.pollLast());
count--;
this.notifyAll();
}
if (this.isEmpty()) {    //必须判断
try {
this.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}

public boolean isFull() {
return count == maxSize;
}


public boolean isEmpty() {
return count == 0;
}
}

class Producer implements Runnable {
private Myqueue queue;

public Producer(Myqueue queue) {
this.queue = queue;
}


@Override
public void run() {
while (true) {
queue.put("烤鱼");
}

}
}


class Consumer implements Runnable {
private Myqueue queue;


public Consumer(Myqueue queue) {
this.queue = queue;
}


@Override
public void run() {
while (true) {
queue.get();
}
}

}


2 ReentrantLock实现

import java.util.LinkedList;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLocTest {

/**
* @param args
*/
public static void main(String[] args) {
MyFoods foods = new MyFoods(8);
Productor pd = new Productor(foods);
MyConsumer cs = new MyConsumer(foods);
new Thread(pd).start();
new Thread(pd).start();
new Thread(pd).start();
new Thread(cs).start();
new Thread(cs).start();
new Thread(cs).start();
new Thread(cs).start();
}
}

class MyFoods {
LinkedList<String> foods;
int maxcount;
int index;
ReentrantLock lock;
private Condition noFull;
private Condition noEmpty;

public MyFoods(int count) {
foods = new LinkedList<String>();
maxcount = count;
lock = new ReentrantLock();
noFull = lock.newCondition();
noEmpty = lock.newCondition();
}

public void produce() throws InterruptedException {
lock.lock();
try {
while (foods.size() == maxcount) {
// 已满阻塞
noFull.await();
}
// 可以生产
index++;
foods.addFirst("产品" + index);
System.out.println(Thread.currentThread().getName()
+ "生产++++++++++++产品" + index);
noEmpty.signalAll();
} finally {
lock.unlock();
}
}


public void consume() throws InterruptedException {
lock.lock();
try {
while (foods.isEmpty()) {
// 已空
noEmpty.await();
}
String str = foods.pollLast();
System.out.println(Thread.currentThread().getName() + "消费——"
+ str);
noFull.signalAll();
} finally {
lock.unlock();
}
}
}


class Productor implements Runnable {
MyFoods foods;


public Productor(MyFoods f) {
foods = f;
}


public void run() {
while (true) {
try {
foods.produce();
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}


class MyConsumer implements Runnable {
MyFoods foods;


public MyConsumer(MyFoods f) {
foods = f;
}


public void run() {
while (true) {
try {
foods.consume();
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}

结果如下:



Java 生产者 与 消费者 的实际运用

生产者与消费者模式的实际运用
  • qq1013598664
  • qq1013598664
  • 2016年10月08日 23:24
  • 696

Java多线程之简单生产者和消费者例子

一,在本例子中,有三个类,dataStore(存放数据类),consumer(消费者),producer(生产者)。 二,看源码例子: 类dataStore: import java.lang....
  • ganpengjin1
  • ganpengjin1
  • 2015年04月18日 15:13
  • 1837

Java生产者消费者例子

生产者-消费者(producer-consumer)问题,也称作有界缓冲区(bounded-buffer)问题,两个进程共享一个公共的固定大小的缓冲区。其中一个是生产者,用于将消息放入缓冲区;另外一个...
  • ym19860303
  • ym19860303
  • 2013年08月11日 20:44
  • 1544

JAVA多线程之——经典面试消费者与生产者

用wait与notify、notifyAll 实现生产者与消费者 关于多线程的生产者与消费者有多种方式实现。目前用学过的wait、notifyAll来实现。代码:public class Threa...
  • pengdandezhi
  • pengdandezhi
  • 2017年03月26日 15:23
  • 633

Java多线程之生产者消费者问题<一>:使用synchronized 关键字解决生产者消费者问题

今天看了一片博文,讲Java多线程之线程的协作,其中作者用程序实例说明了生产者和消费者问题,但我及其他读者发现程序多跑几次还是会出现死锁,百度搜了下大都数的例子也都存在bug,经过仔细研究发现其中的问...
  • feichenwangyalin
  • feichenwangyalin
  • 2014年10月16日 22:22
  • 1893

JAVA多线程(三)生产者消费者模式及实现方法

介绍了生产者消费者模式以及实现方法(wait¬ify,阻塞队列
  • antony9118
  • antony9118
  • 2016年05月23日 15:15
  • 2174

生产者消费者问题的java实现

生产者和消费者是多线程经典的问题,生产者和消费者问题的核心是同步的问题,同步问题的核心是要保证同一个资源被多个线程并发访问时的完整性,常用的方法是采用信号或加锁机制,保证资源在任一时刻只能被一个线程访...
  • longshengguoji
  • longshengguoji
  • 2014年11月29日 19:44
  • 3540

Java多线程--生产者消费者模型(Semaphore实现)

需求要求:使用2个线程,分别代表:生产者、消费者。让他们并发的去生产、消费产品。生产的总数是不能超过N的。实现思路这里我们使用的是使用信号量去控制线程的生产消费,通过释放令牌的形式去控制生产者消费者的...
  • qq_24489717
  • qq_24489717
  • 2017年04月12日 21:53
  • 703

java 多线程并发系列之 生产者消费者模式的两种实现

生产者消费者模式是并发、多线程编程中经典的设计模式,生产者和消费者通过分离的执行工作解耦,简化了开发模式,生产者和消费者可以以不同的速度生产和消费数据。 真实世界中的生产者消费者模式...
  • yujin753
  • yujin753
  • 2015年05月14日 16:59
  • 11623

java中的信号量semaphore实现生产者消费者模式

Semaphore 信号量,就是一个允许实现设置好的令牌。也许有1个,也许有10个或更多。  谁拿到令牌(acquire)就可以去执行了,如果没有令牌则需要等待。  执行完毕,一定要归还(rele...
  • mm_bit
  • mm_bit
  • 2015年11月24日 11:59
  • 2305
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:java 生产者消费者
举报原因:
原因补充:

(最多只允许输入30个字)