线程池的queue

• LinkedBlockingQueue 

  采用的是lock进行同步操作，分为put锁   take锁
  
  #默认是无界的，资源容易失控
  #但是可以建立的时候指定容量，capacity
  
  public void put(E e) throws InterruptedException {
          if (e == null) throw new NullPointerException();
          // Note: convention in all put/take/etc is to preset local var
          // holding count negative to indicate failure unless set.
          int c = -1;
          Node<E> node = new Node<E>(e);
          final ReentrantLock putLock = this.putLock;
          final AtomicInteger count = this.count;
          putLock.lockInterruptibly();
          try {
              /*
               * Note that count is used in wait guard even though it is
               * not protected by lock. This works because count can
               * only decrease at this point (all other puts are shut
               * out by lock), and we (or some other waiting put) are
               * signalled if it ever changes from capacity. Similarly
               * for all other uses of count in other wait guards.
               */
              while (count.get() == capacity) {
                  notFull.await();
              }
              enqueue(node);
              c = count.getAndIncrement();
              if (c + 1 < capacity)                  //  这段就是判断是否有界的逻辑
                  notFull.signal();
          } finally {
              putLock.unlock();
          }
          if (c == 0)
              signalNotEmpty();
      }

• ConcurrentLinkedQueue

  基于CAS的无锁技术，不需要在每个操作时使用锁，所以扩展性表现要更加优异，在常见的多线程访问场景，一般可以提供较高吞吐量。
  
  但是这个是无界的，需要考虑容量

• ArrayListBlockingQueue

  final ReentrantLock lock; 只要一把锁
  
  有界的，一般线程池采用这种队列