juc-Queue接口以及其实现类

Queue

BlockingQueue

ArrayBlockingQueue

构造函数

 public ArrayBlockingQueue(int capacity) {
    
        this(capacity, false);
    }

 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();
    }
    
public ArrayBlockingQueue(int capacity, boolean fair,
                              Collection<? extends E> c) {
    
        this(capacity, fair);

        final ReentrantLock lock = this.lock;
        lock.lock(); // Lock only for visibility, not mutual exclusion
        try {
    
            int i = 0;
            try {
    
                for (E e : c) {
    
                    checkNotNull(e);
                    items[i++] = e;
                }
            } catch (ArrayIndexOutOfBoundsException ex) {
    
                throw new IllegalArgumentException();
            }
            count = i;
            putIndex = (i == capacity) ? 0 : i;
        } finally {
    
            lock.unlock();
        }
    }

LinkedBlockingQueue

构造函数

public LinkedBlockingQueue() {
    
        this(Integer.MAX_VALUE);
    }

public LinkedBlockingQueue(int capacity) {
    
        if (capacity <= 0) throw new IllegalArgumentException();
        this.capacity = capacity;
        last = head = new Node<E>(null);
    }
    
public LinkedBlockingQueue(Collection<? extends E> c) {
    
        this(Integer.MAX_VALUE);
        final ReentrantLock putLock = this.putLock;
        putLock.lock(); // Never contended, but necessary for visibility
        try {
    
            int n = 0;
            for (E e : c) {
    
                if (e == null)
                    throw new NullPointerException();
                if (n == capacity)
                    throw new IllegalStateException("Queue full");
                enqueue(new Node<E>(e));
                ++n;
            }
            count.set(n);
        } finally {
    
            putLock.unlock();
        }
    }

PriorityBlockingQueue

构造函数

public PriorityBlockingQueue() {
    
        this(DEFAULT_INITIAL_CAPACITY, null);
    }

public PriorityBlockingQueue(Collection<? extends E> c) {
    
        this.lock = new ReentrantLock();
        this.notEmpty = lock.newCondition();
        boolean heapify = true; // true if not known to be in heap order
        boolean screen = true;  // true if must screen for nulls
        if (c instanceof SortedSet<?>) {
    
            SortedSet<? extends E> ss = (SortedSet<? extends E>) c;
            this.comparator = (Comparator<? super E>) ss.comparator();
            heapify = false;
        }
        else if (c instanceof PriorityBlockingQueue<?>) {
    
            PriorityBlockingQueue<? extends E> pq =
                (PriorityBlockingQueue<? extends E>) c;
            this.comparator = (Comparator<? super E>) pq.comparator();
            screen = false;
            if (pq.getClass() == PriorityBlockingQueue.class) // exact match
                heapify = false;
        }
        Object[] a = c.toArray();
        int n = a.length;
        // If c.toArray incorrectly doesn't return Object[], copy it.
        if (a.getClass() != Object[].class)
            a = Arrays.copyOf(a, n, Object[].class);
        if (screen && (n == 1 || this.comparator != null)) {
    
            for (int i = 0; i < n; ++i)
                if (a[i] == null)
                    throw new NullPointerException();
        }
        this.queue = a;
        this.size = n;
        if (heapify)
            heapify();
    }
    
public PriorityBlockingQueue(int initialCapacity) {
    
        this(initialCapacity, null);
    }

public PriorityBlockingQueue(int initialCapacity,
                                 Comparator<? super E> comparator) {
    
        if (initialCapacity < 1)
            throw new IllegalArgumentException();
        this.lock = new ReentrantLock();
        this.notEmpty = lock.newCondition();
        this.comparator = comparator;
        this.queue = new Object[initialCapacity];
    }

SynchronousQueue

public SynchronousQueue() {
    
        this(false);
    }

public SynchronousQueue(boolean fair) {
    
    transferer = fair ? new TransferQueue<E>() : new TransferStack<E>();
}

DelayQueue

public DelayQueue() {
    }
 
public DelayQueue(Collection<? extends E> c) {
    
  this.addAll(c);
}

LinkedTransferQueue

    public LinkedTransferQueue() {
    
    }

    public LinkedTransferQueue(Collection<? extends E> c) {
    
        this();
        addAll(c);
    }