import java.util.Arrays;

import java.util.concurrent.TimeUnit;

import java.util.concurrent.atomic.AtomicInteger;

import java.util.concurrent.locks.Condition;

import java.util.concurrent.locks.ReentrantLock;

 

public class BlockingQueue2<E> implements BlockingQueue<E> {

    private final E[] array;

    private int head;

    private int tail;

    //private int size; //size 会交错执行

    private AtomicInteger size = new AtomicInteger();//初始值为0 //原子变量（原子整数类）保护size

 

    public BlockingQueue2(int capacity) {

        array = (E[]) new Object[capacity];

    }

 

    private ReentrantLock tailLock = new ReentrantLock();

    private Condition tailWaits = tailLock.newCondition();

 

    private ReentrantLock headLock = new ReentrantLock();

    private Condition headWaits = headLock.newCondition();

 

 

    private boolean isFull() {

        return size.get() == array.length;//get（）获得内部包装整数值

    }

 

    private boolean isEmpty() {

        return size.get() == 0;//get（）获得内部包装整数值

    }

 

    @Override

    public String toString() {

        return Arrays.toString(array);

    }

 

    @Override

    public void offer(E e) throws InterruptedException {

        tailLock.lockInterruptibly();

        int c;//添加前元素个数

        try {

            while (isFull()) {

                tailWaits.await();

            }

            array[tail] = e;

            if (++tail == array.length) {

                tail = 0;

            }

            c=size.getAndIncrement();//相当于size++

            //1:读取成员变量size的值

            //2：自增

            //3：结果写回成员变量size

            //通知headWaits

            //headWaits.signal(); //唤醒和锁不配对

            if(c<array.length-1){

                tailWaits.signal();

            }

        } finally {

            tailLock.unlock();

        }

        if(c==0){

            //唤醒等待非空的poll线程

            headLock.lock();

            try {

                headWaits.signal();

            } finally {

                headLock.unlock();//避免中间出现其他异常

            }

        }

 

    }

 

    @Override

    public boolean offer(E e, long timeout) throws InterruptedException {//timeout时间上限，结束等待 假设传如时间为毫秒

        return false;

    }

 

    @Override

    public E poll() throws InterruptedException {

        headLock.lockInterruptibly();

        E e;

        int c;//取走前元素个数；

        try {

            while (isEmpty()) {

                headWaits.await();

            }

            e = array[head];

            array[head] = null;

            if (++head == array.length) {

                head = 0;

            }

            c=size.getAndDecrement();//相当于size--

            //1:读取成员变量size的值

            //2：自增

            //3：结果写回成员变量size

            //通知tailWaits

            if(c>1){

                headWaits.signal();

            }

        } finally {

            headLock.unlock();

        }

        //唤醒等待不满的offer线程

        if(c==array.length-1){

            tailLock.lock();

            try {

                tailWaits.signal();

            } finally {

                tailLock.unlock();//避免中间出现其他异常

            }

        }

 

        return e;

    }

}