学习的最好方式就是写出来
欢迎光临我的个人小窝：wsfss.top
今天我们就手撸一个循环队列吧，多生产者，单消费者模式，模拟队列满了之后的场景
这里先说明下循环队列的实现原理
- 队列长度固定，队列有头部指针（front）、尾部指针(rear)两个指针
- 每插入一个元素，尾部指针前移一位
- 每取出一个元素，头部指针前移一位
- 队列满了之后，取出一个元素，再加入一个元素，尾部指针归零
- 取元素的个数达到队列最大长度之后，头部指针归零
1、下面上代码实操，先来个接口类
package com.fss.util.queue;
public interface Queue<T> {
/**
* 添加元素
*/
boolean push(T t);
/**
* 取出元素，先进先出
*/
T pop();
/**
* 判断队列是否已满
*/
boolean isFull();
/**
* 判断队列是否为空
*/
boolean isEmpty();
}
复制代码2、再来一个抽象类吧，保证子类自己来实现接口
package com.fss.util.queue;
public abstract class AbstractQueue<T> implements Queue<T> {
@Override
public boolean push(T t) {
throw new UnsupportedOperationException("不支持的方法");
}
@Override
public T pop() {
throw new UnsupportedOperationException("不支持的方法");
}
@Override
public boolean isFull() {
throw new UnsupportedOperationException("不支持的方法");
}
@Override
public boolean isEmpty() {
throw new UnsupportedOperationException("不支持的方法");
}
}
复制代码3、队列实现类
package com.fss.util.queue;
import java.util.Arrays;
public class CycleQueue<T> extends AbstractQueue<T> implements Queue<T>{
// 队列初始化大小
private static final int CAPCAITY = 6;
// 队列头
volatile int front;
// 队列尾
volatile int rear;
// 队列元素
volatile T[] arrays;
public CycleQueue() {
this.arrays = (T[]) new Object[CAPCAITY];
}
/**
* 添加元素，队尾下标+1
*/
@Override
public boolean push(T t) {
synchronized (this) {
if (!isFull()) {
arrays[rear] = t;
// 队尾指针+1后的值等于队列容积时，队尾下标重置为0，以实现队列循环使用
if (++rear == CAPCAITY) {
rear = 0;
}
return true;
}
return false;
}
}
/**
* 取出元素，队列头下标+1
*/
@Override
public T pop() {
synchronized (this) {
if (!isEmpty()) {
System.out.print("当前数组： ");
for (int i=0; i<arrays.length; i++) {
System.out.print(arrays[i] + ",");
}
System.out.print(" - ");
final T cur = arrays[front];
arrays[front] = null;
front++;
// 队头指针+1后的值等于队列容积时，队头下标重置为0，以实现队列循环使用
if (front == CAPCAITY) {
front = 0;
}
return cur;
}
return null;
}
}
/**
* 判断队列是否满
*/
@Override
public boolean isFull() {
synchronized (this) {
return front == rear && arrays[rear] != null;
}
}
/**
* 判断队列是否为空
*/
@Override
public boolean isEmpty() {
synchronized (this) {
return front == rear && arrays[rear] == null;
}
}
}
复制代码4、大功告成，现在起3个线程类，2个生产者，1一个消费者，生产速度大于消费速度
- 生产者（当队列满了之后等待，有元素被取出则继续生产）
package com.fss.util.thread;
import com.fss.util.queue.CycleQueue;
import java.util.Random;
public class PushQueueThread extends Thread{
private CycleQueue queue;
private String threadName;
public PushQueueThread(CycleQueue queue, String threadName) {
this.queue = queue;
this.threadName = threadName;
}
@Override
public void run() {
synchronized (queue) {
while (true) {
int i = new Random().nextInt(1000);
while (queue.isFull()) {
try {
System.out.print(threadName + " - 发现队列满了，排队等位中。。。。\n");
queue.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
queue.push(i);
System.out.print(threadName + "-放入元素： " + i + "\n");
try {
queue.wait(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
复制代码- 消费者（取出元素之后通知生产者生产）
package com.fss.util.thread;
import com.fss.util.queue.CycleQueue;
import java.util.List;
public class PopQueueThread extends Thread{
private CycleQueue queue;
private String threadName;
public PopQueueThread(CycleQueue queue, String threadName) {
this.queue = queue;
this.threadName = threadName;
}
@Override
public void run() {
synchronized (queue) {
while (true) {
if (!queue.isEmpty()) {
Object o = queue.pop();
System.out.print(threadName + "-取出元素: "+o + "\n");
try {
queue.wait(100);
System.out.println(threadName + " - 有空位了，下一位上来吧。。。");
queue.notifyAll();
} catch (InterruptedException e) {
e.printStackTrace();
}
} else {
try {
System.out.print(threadName + " - 发现队列空了，坐等客人上门。。。。\n");
queue.wait(200);
queue.notifyAll();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
}
复制代码5、起一个main方法测试吧
package test;
import com.fss.util.queue.CycleQueue;
import com.fss.util.thread.PopQueueThread;
import com.fss.util.thread.PushQueueThread;
public class CycleQueueTest {
public static void main(String[] args) {
CycleQueue queue = new CycleQueue();
PushQueueThread pushThread1 = new PushQueueThread(queue, "Push1");
PushQueueThread pushThread2 = new PushQueueThread(queue, "Push2");
PopQueueThread popThread = new PopQueueThread(queue, "Pop1");
pushThread1.start();
pushThread2.start();
popThread.start();
}
}
复制代码输出结果
Push1-放入元素： 148
Push2-放入元素： 694
当前数组： 148,694,null,null,null,null, - Pop1-取出元素: 148
Push1-放入元素： 797
Push2-放入元素： 781
Pop1 - 有空位了，下一位上来吧。。。
当前数组： null,694,797,781,null,null, - Pop1-取出元素: 694
Push2-放入元素： 639
Push1-放入元素： 390
Push2-放入元素： 633
Pop1 - 有空位了，下一位上来吧。。。
当前数组： 633,null,797,781,639,390, - Pop1-取出元素: 797
Push1-放入元素： 843
Push2-放入元素： 945
Pop1 - 有空位了，下一位上来吧。。。
当前数组： 633,843,945,781,639,390, - Pop1-取出元素: 781
Push2-放入元素： 33
Push1 - 发现队列满了，排队等位中。。。。
Pop1 - 有空位了，下一位上来吧。。。
复制代码