[Java知识库]自己实现一个阻塞队列 模仿ArrayBlockingQueue

通过条件队列的等待通知模式来实现 一个基于数组的 有限的阻塞队列

package ThreeYue;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 一个阻塞的FIFO队列
 * @param <E>
 */
public class MyBlockingQueue<E> {
    private ReentrantLock lock;
    private Condition notEmpty;//队列空了，消费者线程阻塞到这里
    private Condition notFull;//队列满了，生产者线程阻塞到这里

    private int count;//队列容量
    private int takeIndex;//为了tak使用 用来保证FIFO
    private int putIndex;//为了offer使用
    final Object[] items;

    public MyBlockingQueue(int count) {
        this.count = count;
        this.items = new Object[count];
        lock = new ReentrantLock();
        notEmpty = lock.newCondition();
        notFull = lock.newCondition();
    }

    //加入元素，如果队列满了就阻塞
    public void offer(E item) {
        lock.lock();
        try {
            while(count == items.length) {
                System.out.println("   --生产者被阻塞--");
                notFull.await();
            }
            items[putIndex] = item;
            if (++putIndex == items.length) {
                putIndex = 0;
            }
            count++;
            System.out.println(Thread.currentThread().getName() + " 生产 " + item);
            System.out.println("sc:此时队列中西瓜个数为" + count);
            notEmpty.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    //取出元素，队列空了就阻塞
    public E take() throws InterruptedException {
        lock.lock();
        try {
            while (count == 0) {
                System.out.println("   --消费者被阻塞--");
                notEmpty.await();
            }
            E x = (E) items[takeIndex];
            items[takeIndex] = null;
            if (++takeIndex == items.length) {
                takeIndex = 0;
            }
            count--;
            System.out.println(Thread.currentThread().getName()+" 吃 西瓜");
            System.out.println("xf:此时队列中西瓜个数为" + count);
            notFull.signal();
            return x;
        } finally {
            lock.unlock();
        }
    }

    //测试 一个生产者不断生产 俩个消费者不断消费
    public static void main(String[] args) {
        MyBlockingQueue<String> queue = new MyBlockingQueue<>(3);
        new Thread(()->{
            while(true) {
                queue.offer("西瓜");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"生产者线程1").start();

        new Thread(()->{
            while(true) {
                try {
                    queue.take();
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"消费者线程1").start();

//        new Thread(()->{
//            while(true) {
//                queue.offer("西瓜");
//                try {
//                    Thread.sleep(1000);
//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                }
//            }
//        },"生产者线程2").start();

        new Thread(()->{
            while(true) {
                try {
                    queue.take();
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"消费者线程2").start();
    }

}

西安今天好热。。。
使用结果

   --生产者被阻塞--
消费者线程1 吃 西瓜
xf:此时队列中西瓜个数为2
生产者线程1 生产 西瓜
sc:此时队列中西瓜个数为3
消费者线程2 吃 西瓜
xf:此时队列中西瓜个数为2
消费者线程1 吃 西瓜
xf:此时队列中西瓜个数为1
生产者线程1 生产 西瓜
sc:此时队列中西瓜个数为2
消费者线程2 吃 西瓜
xf:此时队列中西瓜个数为1
消费者线程1 吃 西瓜
xf:此时队列中西瓜个数为0
   --消费者被阻塞--
生产者线程1 生产 西瓜
sc:此时队列中西瓜个数为1
消费者线程2 吃 西瓜
xf:此时队列中西瓜个数为0
生产者线程1 生产 西瓜
sc:此时队列中西瓜个数为1
消费者线程1 吃 西瓜
xf:此时队列中西瓜个数为0
   --消费者被阻塞--
生产者线程1 生产 西瓜
sc:此时队列中西瓜个数为1
消费者线程1 吃 西瓜
xf:此时队列中西瓜个数为0
   --消费者被阻塞--
生产者线程1 生产 西瓜
sc:此时队列中西瓜个数为1
消费者线程1 吃 西瓜
xf:此时队列中西瓜个数为0
   --消费者被阻塞--
生产者线程1 生产 西瓜
sc:此时队列中西瓜个数为1
消费者线程1 吃 西瓜
xf:此时队列中西瓜个数为0
   --消费者被阻塞--
   --消费者被阻塞--
生产者线程1 生产 西瓜
sc:此时队列中西瓜个数为1
消费者线程2 吃 西瓜
xf:此时队列中西瓜个数为0