阻塞队列实现原理

阻塞队列原理

• 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