生产者与消费者模式
今天下一下生产者模式与消费者模式：为了面试而准备，就不细细介绍了，为了让自己面试时体会一下
接下来我来写集中消费者与生产者模式的实现？
Round 1：ReentrantLock和Condition实现消费者与生产者模式
/**
* 共享资源类
*/
class ShareData {
private int num = 0;
private Lock lock = new ReentrantLock();
private Condition condition = lock.newCondition();
public void increment() throws Exception {
lock.lock();
try {
//判断
while (num != 0) {
//等待 不生产
condition.await();
}
//干活
num++;
System.out.println(Thread.currentThread().getName() + "\t" + num);
//通知唤醒
condition.signalAll();
} finally {
lock.unlock();
}
}
public void deIncrement() throws Exception {
lock.lock();
try {
//判断
while (num == 0) {
//等待 不生产
condition.await();
}
//干活
num--;
System.out.println(Thread.currentThread().getName() + "\t" + num);
//通知唤醒
condition.signalAll();
} finally {
lock.unlock();
}
}
}
public class ProdConsumerTraditionDemo {
public static void main(String[] args) {
ShareData shareData = new ShareData();
new Thread(() -> {
for (int i = 1; i <= 5; i++) {
try {
shareData.increment();
} catch (Exception e) {
e.printStackTrace();
}
}
}, "AA").start();
new Thread(() -> {
for (int i = 1; i <= 5; i++) {
try {
shareData.deIncrement();
} catch (Exception e) {
e.printStackTrace();
}
}
}, "BB").start();
}
}
Round 2：阻塞队列实现生产者与消费者模式
class MyResource {
/**
* 默认开启 进行生产消费的交互
*/
private volatile boolean flag = true;
/**
* 默认值是0
*/
private AtomicInteger atomicInteger = new AtomicInteger();
private BlockingQueue<String> blockingQueue = null;
public MyResource(BlockingQueue<String> blockingQueue) {
this.blockingQueue = blockingQueue;
System.out.println(blockingQueue.getClass().getName());
}
public void myProd() throws Exception {
String data = null;
boolean returnValue;
while (flag) {
data = atomicInteger.incrementAndGet() + "";
returnValue = blockingQueue.offer(data, 2L, TimeUnit.SECONDS);
if (returnValue) {
System.out.println(Thread.currentThread().getName() + "\t 插入队列数据" + data + "成功");
} else {
System.out.println(Thread.currentThread().getName() + "\t 插入队列数据" + data + "失败");
}
TimeUnit.SECONDS.sleep(1);
}
System.out.println(Thread.currentThread().getName() + "\t 停止 表示 flag" + flag);
}
public void myConsumer() throws Exception {
String result = null;
while (flag) {
result = blockingQueue.poll(2L, TimeUnit.SECONDS);
if(null==result||"".equalsIgnoreCase(result)){
flag=false;
System.out.println(Thread.currentThread().getName()+"\t"+"超过2m没有取到 消费退出");
System.out.println();
System.out.println();
return;
}
System.out.println(Thread.currentThread().getName() + "消费队列" + result + "成功");
}
}
public void stop() throws Exception{
flag=false;
}
}
public class ProdConsumerBlockQueueDemo {
public static void main(String[] args) throws Exception {
MyResource myResource = new MyResource(new ArrayBlockingQueue<>(10));
new Thread(()->{
System.out.println(Thread.currentThread().getName()+"\t生产线程启动");
try {
myResource.myProd();
} catch (Exception e) {
e.printStackTrace();
}
},"Prod").start();
new Thread(()->{
System.out.println(Thread.currentThread().getName()+"\t消费线程启动");
try {
myResource.myConsumer();
} catch (Exception e) {
e.printStackTrace();
}
},"consumer").start();
try { TimeUnit.SECONDS.sleep(5); } catch (InterruptedException e) { e.printStackTrace(); }
System.out.println();
System.out.println();
System.out.println();
System.out.println("时间到,停止活动");
myResource.stop();
}
}
Round 3：synchronized实现生产者与消费者模式
//悲观锁的实现
public class PessimisticLockPattern {
public static void main(String[] args) {
SelfQueue2 selfqueue = new SelfQueue2();
//创建生产者线程和消费者线程
Thread prodThread = new Thread(new Producer2(selfqueue));
Thread consThread = new Thread(new Consumer2(selfqueue));
//启动生产者线程和消费者线程
prodThread.start();
consThread.start();
}
}
class SelfQueue2{
int index = 0;
int[] ProdLine = new int[6];
public synchronized void produce(int ProdRandom){
while(index == ProdLine.length) {
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
this.notify();
ProdLine[index] = ProdRandom;
index++;
}
public synchronized int consume() {
while(index == 0) {
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
this.notify();
index--;
return ProdLine[index];
}
}
//生产者
class Producer2 implements Runnable {
private final SelfQueue2 selfqueue;
public Producer2(SelfQueue2 selfqueue) {
this.selfqueue = selfqueue;
}
@Override
public void run() {
for(int i=0; i<10; i++) {
Random random = new Random();
int ProdRandom = random.nextInt(10);
System.out.println("Produced: " +ProdRandom);
selfqueue.produce(ProdRandom);
}
}
}
//消费者
class Consumer2 implements Runnable {
private final SelfQueue2 selfqueue;
public Consumer2(SelfQueue2 selfqueue) {
this.selfqueue = selfqueue;
}
@Override
public void run() {
while(true) {
System.out.println("Consumed: " + selfqueue.consume());
}
}
}
Round 4：wait和notify实现生产者与消费者模式
public class Test1 {
private static Integer count = 0;
private static final Integer FULL = 10;
private static String LOCK = "lock";
public static void main(String[] args) {
Test1 test1 = new Test1();
new Thread(test1.new Producer()).start();
new Thread(test1.new Consumer()).start();
new Thread(test1.new Producer()).start();
new Thread(test1.new Consumer()).start();
new Thread(test1.new Producer()).start();
new Thread(test1.new Consumer()).start();
new Thread(test1.new Producer()).start();
new Thread(test1.new Consumer()).start();
}
class Producer implements Runnable {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
try {
Thread.sleep(3000);
} catch (Exception e) {
e.printStackTrace();
}
synchronized (LOCK) {
while (count == FULL) {
try {
LOCK.wait();
} catch (Exception e) {
e.printStackTrace();
}
}
count++;
System.out.println(Thread.currentThread().getName() + "生产者生产，目前总共有" + count);
LOCK.notifyAll();
}
}
}
}
class Consumer implements Runnable {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (LOCK) {
while (count == 0) {
try {
LOCK.wait();
} catch (Exception e) {
}
}
count--;
System.out.println(Thread.currentThread().getName() + "消费者消费，目前总共有" + count);
LOCK.notifyAll();
}
}
}
}
}Round 5：信号量Semaphore实现生产者与消费者模式
public class SemaphoreDemo {
public static void main(String[] args) {
Semaphore semaphore=new Semaphore(3);//模拟3个停车位
for(int i=1;i<=3;i++){//模拟6部汽车
new Thread(()->{
try{
semaphore.acquire();
System.out.println(Thread.currentThread().getName()+"\t抢到车位");
try{
TimeUnit.SECONDS.sleep(3);
}catch (Exception e){
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"\t停车3秒后离开车位");
}catch (Exception e){
e.printStackTrace();
}finally {
semaphore.release();
}
},String.valueOf(i)).start();
}
}
}
