Java实现消费者与生产者模式的3种方式
在本文中，将 Dog 对象中的 name 属性作为生产的对象与消费的对象，当 name 不为空时，生产者（Producer）等待，唤醒消费者（Consumer）,当 name 为空时，Consumer等待，唤醒Producer
Dog的定义
package com.taotao.springboot.bean;
public class Dog {
private String name;
public Dog(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
接下来就使用 Synchronized ReentrantLock LinkedTransferQueue 三种方式实现生产者与消费者模式
1、Synchronized同步锁实现
package com.taotao.springboot;
import com.taotao.springboot.bean.Dog;
import com.taotao.springboot.bean.Person;
import java.util.concurrent.atomic.LongAdder;
public class ProducerComsumerBySycn {
static class Producer extends Thread{
private Object lock;
private Dog dog;
LongAdder adder = new LongAdder();
public Producer(Object lock, Dog dog) {
super();
this.lock = lock;
this.dog = dog;
}
@Override
public void run() {
while (true) {
//wait notify必须在同步代码块中进行
synchronized (lock) {
try {
if (dog.getName() != null) {
//已有dog 等待
lock.wait();
} else {
//生产dog
adder.increment();
dog.setName("dog "+adder.sum());
System.out.println("生产 :"+dog.getName());
//唤醒消费者
lock.notifyAll();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
static class Consumer extends Thread{
private Object lock;
private Dog dog;
public Consumer(Object lock, Dog dog) {
super();
this.lock = lock;
this.dog = dog;
}
@Override
public void run() {
while (true){
//wait notify必须在同步代码块中进行
synchronized (lock) {
try {
if (dog.getName() != null) {
System.out.println("消费 :"+dog.getName());
dog.setName(null);
//睡眠2s,不让程序跑太快
Thread.sleep(2000L);
//唤醒生产者
lock.notifyAll();
} else {
//没有person 可以消费 则等待
lock.wait();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
public static void main(String[] args) {
Dog dog = new Dog(null);
//锁
Object lock = new Object();
//生产者线程
Thread producer = new Thread(new Producer(lock,dog));
//消费者线程
Thread consumer = new Thread(new Consumer(lock,dog));
producer.start();
consumer.start();
}
}
2、ReentrantLock可重入锁实现
package com.taotao.springboot;
import com.taotao.springboot.bean.Dog;
import java.util.concurrent.atomic.LongAdder;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
public class ProducerConsumerByReen {
static class Producer extends Thread {
private ReentrantLock lock;
private Dog dog;
LongAdder adder = new LongAdder();
private Condition consumerCondition;
private Condition producerCondition;
public Producer(ReentrantLock lock, Dog dog, Condition consumerCondition, Condition producerCondition) {
super();
this.lock = lock;
this.dog = dog;
this.consumerCondition = consumerCondition;
this.producerCondition = producerCondition;
}
@Override
public void run() {
while (true) {
try {
lock.lock();
if (dog.getName() != null) {
//已有dog 等待
producerCondition.await();
} else {
//生产dog
adder.increment();
dog.setName("dog " + adder.sum());
System.out.println("生产 :" + dog.getName());
//唤醒消费者
consumerCondition.signalAll();
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
}
static class Consumer extends Thread {
private ReentrantLock lock;
private Dog dog;
private Condition consumerCondition;
private Condition producerCondition;
public Consumer(ReentrantLock lock, Dog dog, Condition consumerCondition, Condition producerCondition) {
super();
this.lock = lock;
this.dog = dog;
this.consumerCondition = consumerCondition;
this.producerCondition = producerCondition;
}
@Override
public void run() {
while (true) {
//wait notify必须在同步代码块中进行
try {
lock.lock();
if (dog.getName() != null) {
System.out.println("消费 :" + dog.getName());
dog.setName(null);
//睡眠2s,不让程序跑太快
Thread.sleep(2000L);
//唤醒生产者
producerCondition.signalAll();
} else {
//没有person 可以消费 则等待
consumerCondition.await();
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
}
public static void main(String[] args) {
Dog dog = new Dog(null);
//锁
ReentrantLock lock = new ReentrantLock();
//消费者condition,控制消费者线程
Condition consumerCondition = lock.newCondition();
//生产者condition,控制生产者线程
Condition producerCondition = lock.newCondition();
//生产者线程
Thread producer = new Thread(new Producer(lock, dog, consumerCondition, producerCondition));
//消费者线程
Thread consumer = new Thread(new Consumer(lock, dog, consumerCondition, producerCondition));
producer.start();
consumer.start();
}
}
3、LinkedTransferQueue队列实现
测试类
package com.ruiyun.test;
import java.util.concurrent.LinkedTransferQueue;
public class TransferQueueTest {
public static void main(String[] args) {
LinkedTransferQueue<Dog> dogs = new LinkedTransferQueue<>();
Product product = new Product(dogs);
Comsumer comsumer = new Comsumer(dogs);
Thread comThread = new Thread(comsumer);
Thread prothread = new Thread(product);
prothread.start();
comThread.start();
}
}
生产者
package com.ruiyun.test;
import java.util.concurrent.LinkedTransferQueue;
import java.util.concurrent.atomic.LongAdder;
public class Product extends Thread {
private LinkedTransferQueue<Dog> queue;
private LongAdder adder = new LongAdder();
public Product(LinkedTransferQueue<Dog> queue) {
super();
this.queue = queue;
}
@Override
public void run() {
while(true){
try {
adder.increment();
Thread.sleep(1000L);
Dog dog = new Dog("dog"+adder.sum());
//关键实现，消费者空闲时候才会调用transfer()方法，不然会一直阻塞
queue.transfer(dog);
System.out.println("product:"+dog.getName());
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
消费者
package com.ruiyun.test;
import java.util.concurrent.LinkedTransferQueue;
public class Comsumer extends Thread{
private LinkedTransferQueue<Dog> queue;
public Comsumer(LinkedTransferQueue<Dog> queue) {
super();
this.queue = queue;
}
@Override
public void run() {
while(true){
try {
//从队列里移除第一个元素，如果队列为空，则阻塞
Dog take = queue.take();
System.out.println("comsumer:"+take.getName());
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}