Java源码解析阻塞队列ArrayBlockingQueue介绍

java的阻塞队列，在实现时，使用到了lock和condition，下面是对其主要方法的介绍。

首先看一下，阻塞队列中使用到的锁。

/** main lock guarding all access **/
  final reentrantlock lock;​
  /** condition for waiting takes **/
  private final condition notempty;​
  /** condition for waiting puts **/
  private final condition notfull;

主要的锁是一个可重入锁，根据注释，它是用来保证所有访问的同步。此外，还有2个condition，notempty用于take等待，notfull用于put等待。

两个condition的初始化方法如下：

public arrayblockingqueue(int capacity, boolean fair) {
    if (capacity <= 0)
      throw new illegalargumentexception();
    this.items = new object[capacity];
    lock = new reentrantlock(fair);
    notempty = lock.newcondition();
    notfull = lock.newcondition();
  }

下面介绍一下put方法。代码如下。

public void put(e e) throws interruptedexception {
    checknotnull(e);
    final reentrantlock lock = this.lock;
    lock.lockinterruptibly();
    try {
      while (count == items.length)
        notfull.await();
      enqueue(e);
    } finally {
      lock.unlock();
    }
  }

进行put时，首先对待插入的元素进行了非null判断。然后获取锁。之后用一个循环进行判断，如果元素已满，那么，就调用notfull的await方法，进行阻塞。当有别的线程（其实是take元素的线程）调用notfull的siginal方法后，put线程会被唤醒。唤醒后再确认一下count是否小于items.length，如果是，则进行加入队列的操作。

下面介绍一下take方法，代码如下：

public e take() throws interruptedexception {
    final reentrantlock lock = this.lock;
    lock.lockinterruptibly();
    try {
      while (count == 0)
        notempty.await();
      return dequeue();
    } finally {
      lock.unlock();
    }
  }

进行take时，同样先要获取锁，然后判断元素个数是否为0，为0时需要等待在notempty条件上，等待被唤醒。唤醒之后，会再进行一次元素个数判断，然后进行出队列操作。

分析代码到这里的时候，我产生了一个疑问，如果当前队列慢了，执行put的线程在获取到锁之后，等待notfull条件上。那么，当执行take操作的线程想获取锁时，阻塞队列的锁已经被前面put的线程获取了，那么take将永远得不到机会执行。怎么回事呢？

后来，我查了condition的await方法，它的注释如下：

• causes the current thread to wait until it is signalled or interrupted.
• the lock associated with this condition is atomically released and the current thread becomes disabled for thread scheduling purposes and lies dormant until one of four things happens......

原因在await方法的作用上。因为condition是通过lock创建的，而调用condition的await方法时，会自动释放和condition关联的锁。所以说，当put线程被阻塞后，它实际已经释放了锁了。所以，当有take线程想执行时，它是可以获取到锁的。

另一个问题：当等待在condition上的线程被唤醒时，因为之前调用await前，已经获取了锁，那么被唤醒时，它是自动就拥有了锁，还是需要重新获取呢？

在await方法的注释中，有如下的一段话：

• in all cases, before this method can return the current thread must re-acquire the lock associated with this condition. when the thread returns it is guaranteed to hold this lock.

说明当等待在condition上的线程被唤醒时，它需要重新获取condition关联的锁，获取到之后，await方法才会返回。

总结

以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作具有一定的参考学习价值，谢谢大家对的支持。如果你想了解更多相关内容请查看下面相关链接