阻塞队列原理
- java中ArrayBlockingQueue相信都用过,之前仅仅是使用没有了解其背后原理,知其然不知其所以然,这种学习方法是错误的,上学的时候老师总是告诉我们好记性不如烂笔头,相信如果自己手写一遍理解的更深刻。
- 实际上阻塞队列在异步编程经常使用,典型应用生产者消费者模型。
- 代码如下:
mport java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
/**
* @Author : zzz
* @Date : Created in 19:58 2020/3/5
* @Description : 复习知识点,手写简易版阻塞队列
*/
public class MyBlockingQueue<E> {
final ReentrantLock lock ;
final Condition notFull;
final Condition notEmpty;
private int takeIndex = 0;
private int putIndex = 0;
//计数器
private int count = 0;
//容量
private final int capacity;
private final Object[] items;
//默认按照公平锁实现简易版
public MyBlockingQueue(int capacity) {
this.capacity = capacity;
items = new Object[capacity];
lock = new ReentrantLock();
notFull = lock.newCondition();
notEmpty = lock.newCondition();
}
public void put(E e) throws InterruptedException {
//响应中断
lock.lockInterruptibly();
try {
//元素个数等于数组长度
while (items.length == count) {
notFull.await();
}
items[putIndex] = e;
++putIndex;
System.out.println("生产者线程:" + count + ",putIndex=" + putIndex);
if (putIndex == items.length) {
putIndex = 0;
}
count++;
notEmpty.signal();
} finally {
lock.unlock();
}
}
public E take() throws InterruptedException {
lock.lockInterruptibly();
try {
//元素个数为0
while (count == 0) {
notEmpty.await();
}
E e = (E)items[takeIndex];
items[takeIndex] = null;
System.out.println("消费者线程count:" + count + ",takeIndex=" + takeIndex);
//刚开始写成了++takeIndex == count
if (++takeIndex == items.length) {
System.out.println("居然为0");
takeIndex = 0;
}
count--;
notFull.signal();
return e;
} finally {
lock.unlock();
}
}
public static void main(String[] args) throws InterruptedException {
MyBlockingQueue<String> queue = new MyBlockingQueue<>(10);
Thread producer1 = new Thread(new Runnable() {
@Override
public void run() {
int i=0;
while (true) {
try {
queue.put((i++) + "");
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
});
/* Thread producer2 = new Thread(new Runnable() {
@Override
public void run() {
while (true) {
try {
queue.put(Math.random() + "");
Thread.sleep(10000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
});*/
Thread consumer = new Thread(new Runnable() {
@Override
public void run() {
while (true) {
try {
String ele = queue.take();
System.out.println("消费者线程获取元素" + ele);
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
});
producer1.start();
// producer2.start();
consumer.start();
producer1.join();
//producer2.join();
consumer.join();
}
}
控制台输出:代码中生产者1秒生产一个放入队列,消费者3秒消费一个,生产者生产快于消费者。虽然很简单,但自己手写一遍遇到很多问题,自己定位自己解决,这个过程对理解原理很有益处。
生产者线程:0,putIndex=1
消费者线程count:1,takeIndex=0
消费者线程获取元素0
生产者线程:0,putIndex=2
生产者线程:1,putIndex=3
生产者线程:2,putIndex=4
消费者线程count:3,takeIndex=1
消费者线程获取元素1
生产者线程:2,putIndex=5
生产者线程:3,putIndex=6
消费者线程count:4,takeIndex=2
消费者线程获取元素2
生产者线程:3,putIndex=7
生产者线程:4,putIndex=8
生产者线程:5,putIndex=9
消费者线程count:6,takeIndex=3
消费者线程获取元素3
生产者线程:5,putIndex=10
生产者线程:6,putIndex=1
生产者线程:7,putIndex=2
消费者线程count:8,takeIndex=4
消费者线程获取元素4
生产者线程:7,putIndex=3
生产者线程:8,putIndex=4
生产者线程:9,putIndex=5
消费者线程count:10,takeIndex=5
消费者线程获取元素5
生产者线程:9,putIndex=6
消费者线程count:10,takeIndex=6
消费者线程获取元素6
生产者线程:9,putIndex=7
消费者线程count:10,takeIndex=7
生产者线程:9,putIndex=8
消费者线程获取元素7
消费者线程count:10,takeIndex=8
消费者线程获取元素8
生产者线程:9,putIndex=9
Process finished with exit code -1