阻塞队列-单锁实现

使用阻塞队列  

当我们多个线程下 对 一个队列进行操作，队列满了的情况下，其他线程再次 offer，会一直阻塞等待

对一个队列进行出队操作的时候，队列空的情况下，会一直阻塞等待删除，直到队列有元素的时候，会执行删除操作

一直阻塞等待的时候用自旋锁来进行等待

代码如下

阻塞队列接口

public interface BlockingQueue <E>{
    void offer(E e) throws InterruptedException;
    Boolean offer(E e,long timeout) throws InterruptedException;
    E poll() throws InterruptedException;
}

阻塞队列实现

public class ArrayBlockingQueue<E> implements BlockingQueue<E> {
    private final E[] array;
    private int head;//记录出队时候的头指针
    private int tail;//记录入队的指针
    private int size;//记录数组 个数
    private ReentrantLock lock = new ReentrantLock();
    private Condition headWait = lock.newCondition();//控制 入队的 同步队列
    private Condition tailWait = lock.newCondition();//控制出队的同步队列

    public ArrayBlockingQueue(int capacity) {
        array = (E[]) new Object[capacity];
    }

    private Boolean isFull() {
        return size == array.length;
    }

    private Boolean isEmpty() {
        return size == 0;
    }

    @Override
    public String toString() {
        return "ArrayBlockingQueue{" +
                "array=" + Arrays.toString(array) +
                '}';
    }

    /**
     * @param e
     * @throws InterruptedException 在判断是否满的时候 用while循环而不是 if 为了防止虚假唤醒
     */
    @Override
    public void offer(E e) throws InterruptedException {
        lock.lockInterruptibly();
        try {
            while (isFull()) {
                tailWait.await();//如果满了 就让线程加入 同步队列
                // 一直等待被唤醒 使用while防止 多线程下的虚假唤醒
            }
            array[tail] = e;
            if (++tail == array.length) {
                tail = 0;
            }
            size++;
            //唤醒 出队的线程是为了 防止  在一个空队列中，删除元素的线程会一直线程等待，我们唤醒该线程
            //提示他可以删除
            headWait.signal();
        } finally {
            lock.unlock();
        }
    }

    /**
     * @param e
     * @param timeout
     * @return {@code Boolean }
     * @throws InterruptedException 根据 自己传入的时间   设置 入队最多等待的时间 如果
     *                              入队超时    那么返回false 并且该线程不会再等待唤醒
     *                              跟单独使用awaitNanos方法是不一样的
     *                               单独使用 .awaitNanos 方法  当设置的等待时间到期，线程自动启动来竞争锁
     *                               ，竞争不到 会到等待队列中去等待被唤醒
     */

    @Override
    public Boolean offer(E e, long timeout) throws InterruptedException {
        lock.lockInterruptibly();
        //把传入的毫秒 转换成纳秒
        long nanos = TimeUnit.MILLISECONDS.toNanos(timeout);
        try {
            while (isFull()) {
                if (nanos < 0) {
                    //发现等待的时间 <0 表明超过了自己等待的时间 插入操作入队
                    return false;
                }
                nanos = tailWait.awaitNanos(nanos);
            }
                array[tail] = e;
                if (++tail == array.length) {
                    tail = 0;
                }
                size++;
                //唤醒 出队的线程是为了 防止  在一个空队列中，删除元素的线程会一直线程等待，我们唤醒该线程
                //提示他可以删除
                headWait.signal();
                return true;

        } finally {
            lock.unlock();
        }
    }

    @Override
    public E poll() throws InterruptedException {
        lock.lockInterruptibly();
        try {
            while (isEmpty()) {
                headWait.await();
            }
            E e = array[head];
            array[head] = null;
            if (++head == array.length) {
                head = 0;
            }
            size--;
            tailWait.signal();//因为 我们 入队 满了的话线程等待
            // 删除成功之后 队列不满，唤醒入队线程
            return e;
        } finally {
            lock.unlock();
        }
    }
}

测试实现

public class ArrayBlockingQueueTest {
    public static void main(String[] args) throws InterruptedException {
        ArrayBlockingQueue<String> blockingQueue = new ArrayBlockingQueue<String>(3);
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    blockingQueue.offer("任务2");
                    blockingQueue.offer("任务3");
                    blockingQueue.offer("任务4");
                    System.out.println(blockingQueue.offer("任务1", 1000));
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        },"线程1").start();
Thread.sleep(2000);
        System.out.println(blockingQueue.toString());
    }

注意事项

我们只需要注意 condition的awaitnanos 方法，我们等待的时间一到，该线程自动唤醒争抢锁