public JedisSentinelPool(String masterName, Set<String> sentinels,
    final GenericObjectPoolConfig poolConfig, final int connectionTimeout,
    final int soTimeout,
    final String password, final int database,
    final String clientName)

//获取jedis
Jedis jedis = null;
try {
    jedis = jedisSentinelPool.getResource();
    // jedis command
    } catch (Exception e) {
    	logger.error(e.getMessage(), e);
    } finally {
        if (jedis != null)
        	jedis.close();
}

public class PriorityBlockingQueue<E> extends AbstractQueue<E>
    implements BlockingQueue<E>, java.io.Serializable {
    //默认数组容量大小
    private static final int DEFAULT_INITIAL_CAPACITY = 11;

    //数组最大容量
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

    //优先级队列数组，queue[n]的2个左右子元素为queue[2*n+1]和queue[2*(n+1)]
    private transient Object[] queue;

    //队列元素个数
    private transient int size;

    //比较器，构造时可以选择传入，若没有则使用元素的自然排序
    private transient Comparator<? super E> comparator;

    //重入锁
    private final ReentrantLock lock;

    //队列为空的时候条件队列
    private final Condition notEmpty;

    //自旋锁
    private transient volatile int allocationSpinLock;

    //序列化的时候使用PriorityQueue
    private PriorityQueue q;
}

/**
 * 默认构造，使用默认容量，没有比较器
 */
public PriorityBlockingQueue() {
    this(DEFAULT_INITIAL_CAPACITY, null);
}
 
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];
}

public boolean offer(E e) {
    if (e == null)
        throw new NullPointerException();
    final ReentrantLock lock = this.lock;
    lock.lock();//获取锁
    int n, cap;
    Object[] array;
    while ((n = size) >= (cap = (array = queue).length))
        tryGrow(array, cap);//如果元素数量大于数组大小，则进行扩容
    try {
        Comparator<? super E> cmp = comparator;
        if (cmp == null)
            siftUpComparable(n, e, array);
        else
            siftUpUsingComparator(n, e, array, cmp);//自底向上调整堆
        size = n + 1;
        notEmpty.signal();//唤醒在notEmpty等待的线程
    } finally {
        lock.unlock();//释放锁
    }
    return true;
}

//扩容
private void tryGrow(Object[] array, int oldCap) {
    //数组扩容的时候使用自旋锁，不需要锁主锁，先释放
    lock.unlock(); // must release and then re-acquire main lock
    Object[] newArray = null;
    if (allocationSpinLock == 0 &&
        UNSAFE.compareAndSwapInt(this, allocationSpinLockOffset,
                                 0, 1)) {
        try {
            int newCap = oldCap + ((oldCap < 64) ?
                                   (oldCap + 2) : // grow faster if small 双倍扩容
                                   (oldCap >> 1));// 扩容1.5倍
            if (newCap - MAX_ARRAY_SIZE > 0) {    // possible overflow
                int minCap = oldCap + 1;
                if (minCap < 0 || minCap > MAX_ARRAY_SIZE)
                    throw new OutOfMemoryError();
                newCap = MAX_ARRAY_SIZE;
            }
            if (newCap > oldCap && queue == array)
                newArray = new Object[newCap];
        } finally {
            allocationSpinLock = 0;//扩容后释放自旋锁
        }
    }
    if (newArray == null) // back off if another thread is allocating
        Thread.yield();
    lock.lock();
    if (newArray != null && queue == array) {
        queue = newArray;
        System.arraycopy(array, 0, newArray, 0, oldCap);//复制数组元素
    }
}

//使用比较器，自底向上调整堆
private static <T> void siftUpUsingComparator(int k, T x, Object[] array,
                                       Comparator<? super T> cmp) {
    while (k > 0) {
        int parent = (k - 1) >>> 1;
        Object e = array[parent];
        if (cmp.compare(x, (T) e) >= 0)//x比父节点“大”则中止循环
            break;
        array[k] = e;//向上调整父节点
        k = parent;
    }
    array[k] = x;
}

public E take() throws InterruptedException {
    final ReentrantLock lock = this.lock;
    lock.lockInterruptibly();
    E result;
    try {
        while ( (result = dequeue()) == null)
            notEmpty.await();//数组没有元素则阻塞
    } finally {
        lock.unlock();
    }
    return result;
}


private E dequeue() {
    int n = size - 1;
    if (n < 0)
        return null;
    else {
        Object[] array = queue;
        E result = (E) array[0];//取出数组头节点
        E x = (E) array[n];
        array[n] = null;//清掉最后一个元素
        Comparator<? super E> cmp = comparator;
        if (cmp == null)//将数组尾节点自顶向下调整
            siftDownComparable(0, x, array, n);
        else
            siftDownUsingComparator(0, x, array, n, cmp);
        size = n;
        return result;
    }
}
//自顶向下调整
private static <T> void siftDownUsingComparator(int k, T x, Object[] array,
                                                    int n,
                                                    Comparator<? super T> cmp) {
    if (n > 0) {
        int half = n >>> 1; //最后一个叶子节点的父节点位置
        while (k < half) {
            int child = (k << 1) + 1;//左节点
            Object c = array[child];
            int right = child + 1;//右节点
            if (right < n && cmp.compare((T) c, (T) array[right]) > 0)
                c = array[child = right];//取左右节点间较小的
            if (cmp.compare(x, (T) c) <= 0)//父节点和左右节点较小值比较
                break;
            array[k] = c;
            k = child;
        }
        array[k] = x;
    }
}

public boolean remove(Object o) {
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        int i = indexOf(o);//查找o对于的位置
        if (i == -1)//查找不到该元素
            return false;
        removeAt(i);//删除i处元素
        return true;
    } finally {
        lock.unlock();
    }
}

private int indexOf(Object o) {
    if (o != null) {
        Object[] array = queue;
        int n = size;
        for (int i = 0; i < n; i++)//数组遍历
            if (o.equals(array[i]))
                return i;
    }
    return -1;
}

private void removeAt(int i) {
    Object[] array = queue;
    int n = size - 1;
    if (n == i) // removed last element
        array[i] = null;//直接删除数组最后元素
    else {
        E moved = (E) array[n];
        array[n] = null;//调整最后一个元素
        Comparator<? super E> cmp = comparator;
        if (cmp == null)
            siftDownComparable(i, moved, array, n);//从删除的位置处自顶向下调整元素
        else
            siftDownUsingComparator(i, moved, array, n, cmp);
        //经过从上向下调整后，如果是直接将比较节点放在待调整位置，那只能说明这个节点在以它为堆顶的堆里面最小，但不能说明从这个节点就向上查找就最大，所以这里需要自底向上再来一次调整
        if (array[i] == moved) {
            if (cmp == null)
                siftUpComparable(i, moved, array);
            else
                siftUpUsingComparator(i, moved, array, cmp);
        }
    }
    size = n;
}

public class ConcurrentLinkedQueue<E> extends AbstractQueue<E>
        implements Queue<E>, java.io.Serializable {
    
    private transient volatile Node<E> head;

    private transient volatile Node<E> tail;
}

/**
*Node内部类
*/
private static class Node<E> {
    volatile E item;
    volatile Node<E> next;

    /**
    * Constructs a new node.  Uses relaxed write because item can
    * only be seen after publication via casNext.
    */
    Node(E item) {
        UNSAFE.putObject(this, itemOffset, item);
    }
}

public ConcurrentLinkedQueue() {
    head = tail = new Node<E>(null);
}

//创建一个最初包含给定 collection 元素的 ConcurrentLinkedQueue，按照此 collection 迭代器的遍历顺序来添加元素。
public ConcurrentLinkedQueue(Collection<? extends E> c) {
    Node<E> h = null, t = null;
    for (E e : c) {
        checkNotNull(e);
        Node<E> newNode = new Node<E>(e);
        if (h == null)
            h = t = newNode;
        else {
            t.lazySetNext(newNode);
            t = newNode;
        }
    }
    if (h == null)
        h = t = new Node<E>(null);
    head = h;
    tail = t;
}

public boolean offer(E e) {
    checkNotNull(e);//不允许空
    final Node<E> newNode = new Node<E>(e);

    for (Node<E> t = tail, p = t;;) {
        Node<E> q = p.next;
        if (q == null) {
            // p is last node
            if (p.casNext(null, newNode)) {//q是尾节点p的next,设置p的下一节点为newNode
                // Successful CAS is the linearization point
                // for e to become an element of this queue,
                // and for newNode to become "live".
                if (p != t) // hop two nodes at a time
                    casTail(t, newNode);  // Failure is OK.
                return true;
            }
            // Lost CAS race to another thread; re-read next
        }
        else if (p == q)
            // We have fallen off list.  If tail is unchanged, it
            // will also be off-list, in which case we need to
            // jump to head, from which all live nodes are always
            // reachable.  Else the new tail is a better bet.
            p = (t != (t = tail)) ? t : head;//若尾节点没有发生变化的话，那么，应该是头节点发生了变化，则设置p为头节点，然后重新遍历链表；否则(尾节点变化的话)，则设置p为尾节点。
        else
            // Check for tail updates after two hops.
            p = (p != t && t != (t = tail)) ? t : q;//如果p和t相等，则设置p为q。否则的话，判断“尾节点是否发生变化”，没有变化的话，则设置p为q；否则，设置p为尾节点
    }
}

public E poll() {
    // 设置“标记”
    restartFromHead:
    for (;;) {
        for (Node<E> h = head, p = h, q;;) {
            E item = p.item;

            // 情况1
            // 表头的数据不为null，并且“设置表头的数据为null”这个操作成功的话;
            // 则比较“p和h”(若p!=h，即表头发生了变化，则更新表头，即设置表头为p)，然后返回原表头的item值。
            if (item != null && p.casItem(item, null)) {
                if (p != h) // hop two nodes at a time
                    updateHead(h, ((q = p.next) != null) ? q : p);
                return item;
            }
            // 情况2
            // 表头的下一个节点为null，即链表只有一个“内容为null的表头节点”。则更新表头为p，并返回null。
            else if ((q = p.next) == null) {
                updateHead(h, p);
                return null;
            }
            // 情况3
            // 这可能到由于“情况4”的发生导致p=q，在该情况下跳转到restartFromHead标记重新操作。
            else if (p == q)
                continue restartFromHead;
            // 情况4
            // 设置p为q
            else
                p = q;
        }
    }
}

//更新表头为p，并且设置h的next为自身，帮助gc
final void updateHead(Node<E> h, Node<E> p) {
    if (h != p && casHead(h, p))
        h.lazySetNext(h);
}

//遍历链表获取size
public int size() {
    int count = 0;
    for (Node<E> p = first(); p != null; p = succ(p))
        if (p.item != null)
            // Collection.size() spec says to max out
            if (++count == Integer.MAX_VALUE)
                break;
    return count;
}
//返回队列头节点
Node<E> first() {
    restartFromHead:
    for (;;) {
        for (Node<E> h = head, p = h, q;;) {
            boolean hasItem = (p.item != null);
            if (hasItem || (q = p.next) == null) {
                updateHead(h, p);
                return hasItem ? p : null;
            }
            else if (p == q)
                continue restartFromHead;
            else
                p = q;
        }
    }
}

public class LinkedBlockingDeque<E>
    extends AbstractQueue<E>
    implements BlockingDeque<E>, java.io.Serializable {
	
    transient Node<E> first;//表头

    transient Node<E> last;//表尾

    /** Number of items in the deque */
    private transient int count;

    /** Maximum number of items in the deque */
    private final int capacity;

    /** Main lock guarding all access */
    final ReentrantLock lock = new ReentrantLock();

    /** Condition for waiting takes */
    private final Condition notEmpty = lock.newCondition();

    /** Condition for waiting puts */
    private final Condition notFull = lock.newCondition();
}

//双向链表节点
static final class Node<E> {
        /**
         * The item, or null if this node has been removed.
         */
        E item;

        /**
         * One of:
         * - the real predecessor Node
         * - this Node, meaning the predecessor is tail
         * - null, meaning there is no predecessor
         */
        Node<E> prev;

        /**
         * One of:
         * - the real successor Node
         * - this Node, meaning the successor is head
         * - null, meaning there is no successor
         */
        Node<E> next;

        Node(E x) {
            item = x;
        }
    }

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

public LinkedBlockingDeque(int capacity) {
    if (capacity <= 0) throw new IllegalArgumentException();
    this.capacity = capacity;
}
// 创建一个容量为 Integer.MAX_VALUE 的 LinkedBlockingDeque，最初包含给定 collection 的元素，以该 collection 迭代器的遍历顺序添加
public LinkedBlockingDeque(Collection<? extends E> c) {
    this(Integer.MAX_VALUE);
    final ReentrantLock lock = this.lock;
    lock.lock(); // Never contended, but necessary for visibility
    try {
        for (E e : c) {
            if (e == null)
                throw new NullPointerException();
            if (!linkLast(new Node<E>(e)))
                throw new IllegalStateException("Deque full");
        }
    } finally {
        lock.unlock();
    }
}

//添加到队列尾部
public boolean offerLast(E e) {
    if (e == null) throw new NullPointerException();
    Node<E> node = new Node<E>(e);
    final ReentrantLock lock = this.lock;
    lock.lock();//获取锁
    try {
        return linkLast(node);
    } finally {
        lock.unlock();//释放锁
    }
}

private boolean linkLast(Node<E> node) {
    // assert lock.isHeldByCurrentThread();
    if (count >= capacity)
        return false;//如果“双向链表的节点数量” > “容量”，则返回false，表示插入失败
    Node<E> l = last;
    node.prev = l;
    last = node;
    if (first == null)
        first = node;
    else
        l.next = node;
    ++count;
    notEmpty.signal();//唤醒notEmpty上的等待线程
    return true;
}

public E take() throws InterruptedException {
    return takeFirst();//取出头部节点
}

public E takeFirst() throws InterruptedException {
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        E x;
        while ( (x = unlinkFirst()) == null)
            notEmpty.await();//若队列为空，则等待
        return x;
    } finally {
        lock.unlock();
    }
}

private E unlinkFirst() {
    // assert lock.isHeldByCurrentThread();
    Node<E> f = first;
    if (f == null)
        return null;
    Node<E> n = f.next;
    E item = f.item;
    f.item = null;
    f.next = f; // help GC
    first = n;
    if (n == null)
        last = null;
    else
        n.prev = null;
    --count;
    notFull.signal();//唤醒notFull上等待的线程
    return item;
}

/** Forward iterator */
private class Itr extends AbstractItr {
    Node<E> firstNode() { return first; }
    Node<E> nextNode(Node<E> n) { return n.next; }
}

/** Descending iterator */
private class DescendingItr extends AbstractItr {
    Node<E> firstNode() { return last; }
    Node<E> nextNode(Node<E> n) { return n.prev; }
}

public class LinkedBlockingQueue<E> extends AbstractQueue<E>
        implements BlockingQueue<E>, java.io.Serializable {
    
    private final int capacity;//链表容量
    /** Current number of elements */
    private final AtomicInteger count = new AtomicInteger();//链表实际大小
    /**
     * Head of linked list.
     * Invariant: head.item == null
     */
    transient Node<E> head;//从head取数据
    /**
     * Tail of linked list.
     * Invariant: last.next == null
     */
    private transient Node<E> last;//从last插入数据

    /** Lock held by take, poll, etc */
    private final ReentrantLock takeLock = new ReentrantLock();//取出锁

    /** Wait queue for waiting takes */
    private final Condition notEmpty = takeLock.newCondition();//非空 条件

    /** Lock held by put, offer, etc */
    private final ReentrantLock putLock = new ReentrantLock();//插入锁

    /** Wait queue for waiting puts */
    private final Condition notFull = putLock.newCondition();//未满 条件
}

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();
    }
}

public boolean offer(E e) {
    if (e == null) throw new NullPointerException();
    final AtomicInteger count = this.count;
    if (count.get() == capacity)//队列已满
        return false;
    int c = -1;
    Node<E> node = new Node<E>(e);
    final ReentrantLock putLock = this.putLock;
    putLock.lock();//插入锁 加锁
    try {
        if (count.get() < capacity) {
            enqueue(node);//入队
            c = count.getAndIncrement();
            if (c + 1 < capacity)
                notFull.signal();//c+1后队列未满，则唤醒notFull上的等待线程
        }
    } finally {
        putLock.unlock();
    }
    if (c == 0)
        signalNotEmpty();//入队前队列为空，则唤醒notEmpty上的等待线程
    return c >= 0;
}

//添加元素到队列尾部
private void enqueue(Node<E> node) {
    // assert putLock.isHeldByCurrentThread();
    // assert last.next == null;
    last = last.next = node;
}

//唤醒notEmpty上的等待线程
private void signalNotEmpty() {
    final ReentrantLock takeLock = this.takeLock;
    takeLock.lock();
    try {
        notEmpty.signal();
    } finally {
        takeLock.unlock();
    }
}

public E take() throws InterruptedException {
    E x;
    int c = -1;
    final AtomicInteger count = this.count;
    final ReentrantLock takeLock = this.takeLock;
    takeLock.lockInterruptibly();//获取“取出锁”，若当前线程是中断状态，则抛出InterruptedException异常
    try {
        while (count.get() == 0) {//队列为空
            notEmpty.await();
        }
        x = dequeue();//出队
        c = count.getAndDecrement();//取出元素后，将count-1,返回原始count
        if (c > 1)
            notEmpty.signal();//唤醒notEmpty上等待的线程
    } finally {
        takeLock.unlock();
    }
    if (c == capacity)//取出元素前，队列是满的，则唤醒在notFull上等待的线程
        signalNotFull();
    return x;
}
//删除队列头节点,并把head设置为h.next
private E dequeue() {
    // assert takeLock.isHeldByCurrentThread();
    // assert head.item == null;
    Node<E> h = head;
    Node<E> first = h.next;
    h.next = h; // help GC
    head = first;
    E x = first.item;
    first.item = null;
    return x;
}

//唤醒在notFull上等待的线程
private void signalNotFull() {
    final ReentrantLock putLock = this.putLock;
    putLock.lock();
    try {
        notFull.signal();
    } finally {
        putLock.unlock();
    }
}

public Iterator<E> iterator() {
    return new Itr();
}

private class Itr implements Iterator<E> {
    /*
    * Basic weakly-consistent iterator.  At all times hold the next
    * item to hand out so that if hasNext() reports true, we will
    * still have it to return even if lost race with a take etc.
    */

    private Node<E> current;
    private Node<E> lastRet;
    private E currentElement;

    Itr() {
        fullyLock();//同时获取插入锁和取出锁
        try {
            current = head.next;
            if (current != null)
                currentElement = current.item;
        } finally {
            fullyUnlock();
        }
    }
    
    public boolean hasNext() {
        return current != null;
    }
    public E next() {
        fullyLock();
        try {
            if (current == null)
                throw new NoSuchElementException();
            E x = currentElement;
            lastRet = current;
            current = nextNode(current);//下一个节点
            currentElement = (current == null) ? null : current.item;
            return x;
        } finally {
            fullyUnlock();
        }
    }
}

public class ArrayBlockingQueue<E> extends AbstractQueue<E>
        implements BlockingQueue<E>, java.io.Serializable {

    /** The queued items */
    final Object[] items;

    /** items index for next take, poll, peek or remove */
    int takeIndex; 	//下一个被取出元素的索引

    /** items index for next put, offer, or add */
    int putIndex;	//下一个被添加元素的索引

    /** Number of elements in the queue */
    int count;	//队列中元素个数

    /** Main lock guarding all access */
    final ReentrantLock lock;

    /** Condition for waiting takes */
    private final Condition notEmpty;

    /** Condition for waiting puts */
    private final Condition notFull;
}

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

//capacity: 数组容量, fail: true/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();
    }
}

//将e插入阻塞队列尾部，如果队列已满，返回false; 否则插入成功，返回true
public boolean offer(E e) {
    checkNotNull(e);
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        if (count == items.length)
            return false;
        else {
            enqueue(e);
            return true;
        }
    } finally {
        lock.unlock();
    }
}

private void enqueue(E x) {
    // assert lock.getHoldCount() == 1;
    // assert items[putIndex] == null;
    final Object[] items = this.items;
    items[putIndex] = x;
    if (++putIndex == items.length)
        putIndex = 0;
    count++;
    notEmpty.signal();//唤醒notEmpty上等待的线程
}

//取出阻塞队列的头部元素并返回，若队列为空则等待
public E take() throws InterruptedException {
    final ReentrantLock lock = this.lock;
    lock.lockInterruptibly();
    try {
        while (count == 0)
            notEmpty.await();
        return dequeue();
    } finally {
        lock.unlock();
    }
}

private E dequeue() {
    // assert lock.getHoldCount() == 1;
    // assert items[takeIndex] != null;
    final Object[] items = this.items;
    @SuppressWarnings("unchecked")
    E x = (E) items[takeIndex];
    items[takeIndex] = null;
    if (++takeIndex == items.length)
        takeIndex = 0;
    count--;
    if (itrs != null)
        itrs.elementDequeued();
    notFull.signal();//唤醒notFull上等待的线程
    return x;
}