JDK8系列:阻塞队列 之 LinkedTransferQueue(无界阻塞队列)源码解析

1、LinkedTransferQueue 简介

是一个由链表结构构成的无界阻塞TransferQueue队列。相对于其他阻塞队列,多了  tryTransfer 和 transfer 方法。

LinkedTransferQueue是LinkedBlockingQueue、SynchronousQueue(公平模式)、ConcurrentLinkedQueue三者的集合体,它综合了这三者的方法,并且提供了更加高效的实现方式。

存储结构

LinkedTransferQueue使用了一个叫做dual data structure的数据结构,或者叫做dual queue,译为双重数据结构或者双重队列

双重队列是什么意思呢?

放取元素使用同一个队列,队列中的节点具有两种模式,一种是数据节点,一种是非数据节点。

放元素时先跟队列头节点对比,如果头节点是非数据节点,就让他们匹配,如果头节点是数据节点,就生成一个数据节点放在队列尾端(入队)。

取元素时也是先跟队列头节点对比,如果头节点是数据节点,就让他们匹配,如果头节点是非数据节点,就生成一个非数据节点放在队列尾端(入队)。

用图形来表示就是下面这样:

JDK8系列:阻塞队列 之 LinkedTransferQueue(无界阻塞队列)源码解析_第1张图片

不管是放元素还是取元素,都先跟头节点对比,如果二者模式不一样就匹配它们,如果二者模式一样,就入队。

同一时刻队列中只会存储一种类型的节点

通俗的讲就是:队列中的节点有两种状态;还未被消费(数据节点),或者已经被消费(非数据节点)。

put时,与头节点对比;如果是非数据节点(说明此节点已经被take消费了),那么就将其匹配(删除);如果是数据节点(说明前面还有节点未被消费),那么就将新节点放到tail

take时,与头节点对比;如果是数据节点(说明此节点)???

 

2、成员变量 和 构造方法

public class LinkedTransferQueue extends AbstractQueue implements TransferQueue, java.io.Serializable{
    // 序列号
    private static final long serialVersionUID = -3223113410248163686L;

    // 是否是多核
    private static final boolean MP = Runtime.getRuntime().availableProcessors() > 1;

    // 自旋次数
    private static final int FRONT_SPINS   = 1 << 7;

    // 前驱节点正在处理,当前节点需要自旋的次数
    private static final int CHAINED_SPINS = FRONT_SPINS >>> 1;

    // 容忍清除节点失败次数的阈值
    static final int SWEEP_THRESHOLD = 32;

    // 头节点
    transient volatile Node head;
    // 尾节点
    private transient volatile Node tail;

    private transient volatile int sweepVotes;


    // 放取元素的几种方式:
    // 立即返回,用于非超时的poll()和tryTransfer()方法中
    private static final int NOW   = 0; // for untimed poll, tryTransfer
    // 异步,不会阻塞,用于放元素时,因为内部使用无界单链表存储元素,不会阻塞放元素的过程
    private static final int ASYNC = 1; // for offer, put, add
    // 同步,调用的时候如果没有匹配到会阻塞直到匹配到为止
    private static final int SYNC  = 2; // for transfer, take
    // 超时,用于有超时的poll()和tryTransfer()方法中
    private static final int TIMED = 3; // for timed poll, tryTransfer

    private static final sun.misc.Unsafe UNSAFE;
    private static final long headOffset;
    private static final long tailOffset;
    private static final long sweepVotesOffset;
    static {
        try {
            UNSAFE = sun.misc.Unsafe.getUnsafe();
            Class k = LinkedTransferQueue.class;
            headOffset = UNSAFE.objectFieldOffset
                (k.getDeclaredField("head"));
            tailOffset = UNSAFE.objectFieldOffset
                (k.getDeclaredField("tail"));
            sweepVotesOffset = UNSAFE.objectFieldOffset
                (k.getDeclaredField("sweepVotes"));
        } catch (Exception e) {
            throw new Error(e);
        }
    }
}

 

3、方法简介

3.1、主要构造方法

public LinkedTransferQueue() {}

public LinkedTransferQueue(Collection c) {
    this();
    addAll(c);
}

 

3.2、CAS 操作

// CAS methods for fields

// 1、CAS设置tail
private boolean casTail(Node cmp, Node val) {
    return UNSAFE.compareAndSwapObject(this, tailOffset, cmp, val);
}

// 2、CAS设置head
private boolean casHead(Node cmp, Node val) {
    return UNSAFE.compareAndSwapObject(this, headOffset, cmp, val);
}

// 3、CAS设置sweepVotes
private boolean casSweepVotes(int cmp, int val) {
    return UNSAFE.compareAndSwapInt(this, sweepVotesOffset, cmp, val);
}

 

3.3、入队

xfer(E e, boolean haveData, int how, long nanos)的参数分别是:

(1)e表示元素;

(2)haveData表示是否是数据节点,

(3)how表示放取元素的方式,上面提到的四种,NOW、ASYNC、SYNC、TIMED;

(4)nanos表示超时时间;

add(E e)

public boolean add(E e) {
    xfer(e, true, ASYNC, 0);
    return true;
}

offer(E e)

public boolean offer(E e) {
    xfer(e, true, ASYNC, 0);
    return true;
}

offer(E e, long timeout, TimeUnit unit)  

public boolean offer(E e, long timeout, TimeUnit unit) {
    xfer(e, true, ASYNC, 0);
    return true;
}

 put(E e)

public void put(E e) {
    xfer(e, true, ASYNC, 0);
}

 

3.4、出队

remove(Object o)

public boolean remove(Object o) {
    return findAndRemove(o);
}

poll()

public E poll() {
    return xfer(null, false, NOW, 0);
}

poll(long timeout, TimeUnit unit) 

public E poll(long timeout, TimeUnit unit) throws InterruptedException {
    E e = xfer(null, false, TIMED, unit.toNanos(timeout));
    if (e != null || !Thread.interrupted())
        return e;
    throw new InterruptedException();
}

take()  

public E take() throws InterruptedException {
    E e = xfer(null, false, SYNC, 0);
    if (e != null)
        return e;
    Thread.interrupted();
    throw new InterruptedException();
}

 

3.5、移交元素的方法

请注意第二个参数,都是true,也就是这三个方法其实也是放元素的方法

 transfer(E e)

public void transfer(E e) throws InterruptedException {
    if (xfer(e, true, SYNC, 0) != null) {
        Thread.interrupted(); // failure possible only due to interrupt
        throw new InterruptedException();
    }
}

tryTransfer(E e) 

public boolean tryTransfer(E e) {
    return xfer(e, true, NOW, 0) == null;
}

tryTransfer(E e, long timeout, TimeUnit unit) 

public boolean tryTransfer(E e, long timeout, TimeUnit unit) throws InterruptedException {
    if (xfer(e, true, TIMED, unit.toNanos(timeout)) == null)
        return true;
    if (!Thread.interrupted())
        return false;
    throw new InterruptedException();
}

 

3.6、核心方法 :

xfer(E e, boolean haveData, int how, long nanos) 

// haveData : put是true;  take是false
private E xfer(E e, boolean haveData, int how, long nanos) {
    // 不允许放入空元素
    if (haveData && (e == null))
        throw new NullPointerException();
    Node s = null;                        // the node to append, if needed

    retry:
    // 外层循环,自旋,失败就重试
    for (;;) {                            
  
        // 下面这个for循环用于控制匹配的过程
        // 同一时刻队列中只会存储一种类型的节点
        // 从头节点开始尝试匹配,如果头节点被其它线程先一步匹配了,就再尝试其下一个,直到匹配到为止,或者到队列中没有元素为止

        for (Node h = head, p = h; p != null;) { // 找到第一个匹配的节点
            boolean isData = p.isData;  //p节点的模式
            Object item = p.item;       //p节点的值
            // p没有被匹配到
            if (item != p && (item != null) == isData) { 
                // 如果两者模式一样,则不能匹配,跳出循环后尝试入队
                // isData=haveData=true,put和data;   isData=haveData=false,take和非data
                if (isData == haveData)   
                    break;

                // 如果两者模式不一样,则尝试匹配
                // 把p的值设置为e(如果是取元素则e是null,如果是放元素则e是元素值)
                if (p.casItem(item, e)) { 
                    // 匹配成功
                    // for里面的逻辑比较复杂,用于控制多线程同时放取元素时出现竞争的情况的
                    for (Node q = p; q != h;) {
                        // 进入到这里可能是头节点已经被匹配,然后p会变成h的下一个节点 
                        Node n = q.next;  
                        // 如果head还没变,就把它更新成新的节点
                        // 并把它删除(forgetNext()会把它的next设为自己,也就是从单链表中删除了)
                        // 这时为什么要把head设为n呢?因为到这里了,肯定head本身已经被匹配掉了
                        // 而上面的p.casItem()又成功了,说明p也被当前这个元素给匹配掉了
                        // 所以需要把它们俩都出队列,让其它线程可以从真正的头开始,不用重复检查了
                        if (head == h && casHead(h, n == null ? q : n)) {
                            h.forgetNext();
                            break;  //跳出循环
                        }                 // advance and retry

                        // 如果新的头节点为空,或者其next为空,或者其next未匹配,就重试
                        if ((h = head)   == null ||
                                (q = h.next) == null || !q.isMatched())
                            break;        // unless slack < 2
                    }
                    // 唤醒p中等待的线程
                    LockSupport.unpark(p.waiter);
                    // 并返回匹配到的元素
                    return LinkedTransferQueue.cast(item);
                }
            }

            // p已经被匹配了或者尝试匹配的时候失败了
            // 也就是其它线程先一步匹配了p
            // 这时候又分两种情况,p的next还没来得及修改,p的next指向了自己
            // 如果p的next已经指向了自己,就重新取head重试,否则就取其next重试
            Node n = p.next;
            p = (p != n) ? n : (h = head); // Use head if p offlist
        }

        // 到这里肯定是队列中存储的节点类型和自己一样
        // 或者队列中没有元素了
        // 就入队(不管放元素还是取元素都得入队)
        // 入队又分成四种情况:
        // NOW,立即返回,没有匹配到立即返回,不做入队操作
        // ASYNC,异步,元素入队但当前线程不会阻塞(相当于无界LinkedBlockingQueue的元素入队)
        // SYNC,同步,元素入队后当前线程阻塞,等待被匹配到
        // TIMED,有超时,元素入队后等待一段时间被匹配,时间到了还没匹配到就返回元素本身

        // 如果 不是立即返回
        if (how != NOW) {                 // No matches available
            //  新建s节点
            if (s == null)
                s = new Node(e, haveData);
            // 尝试入队
            Node pred = tryAppend(s, haveData);
            // 入队失败,重试
            if (pred == null)
                continue retry;           // lost race vs opposite mode

            // 如果不是异步(同步或者有超时)
            // 就等待被匹配
            if (how != ASYNC)
                return awaitMatch(s, pred, e, (how == TIMED), nanos);
        }
        return e; // not waiting
    }
}

tryAppend(Node s, boolean haveData) 

private Node tryAppend(Node s, boolean haveData) {
    // 从tail开始遍历,把s放到链表尾端
    for (Node t = tail, p = t;;) {        // move p to last node and append
        Node n, u;                        // temps for reads of next & tail
        //  如果首尾都是null,说明链表中还没有元素
        if (p == null && (p = head) == null) {
            // 就让首节点指向s
            // 注意,这里插入第一个元素的时候tail指针并没有指向s
            if (casHead(null, s))
                return s;                 // initialize
        }
        
        // 如果p无法处理,则返回null
        // 这里无法处理的意思是,p和s节点的类型不一样,不允许s入队
        // 比如,其它线程先入队了一个数据节点,这时候要入队一个非数据节点,就不允许,
        // 队列中所有的元素都要保证是同一种类型的节点
        // 返回null后外面的方法会重新尝试匹配重新入队等
        else if (p.cannotPrecede(haveData))
            return null;                  // lost race vs opposite mode

        // 如果p的next不为空,说明不是最后一个节点
        // 则让p重新指向最后一个节点
        else if ((n = p.next) != null)    // not last; keep traversing
            p = p != t && t != (u = tail) ? (t = u) : // stale tail
                        (p != n) ? n : null;      // restart if off list

        // 如果CAS更新s为p的next失败
        // 则说明有其它线程先一步更新到p的next了
        // 就让p指向p的next,重新尝试让s入队
        else if (!p.casNext(null, s))
            p = p.next;                   // re-read on CAS failure

        // 到这里说明s成功入队了
        // 如果p不等于t,就更新tail指针
        // 还记得上面插入第一个元素时tail指针并没有指向新元素吗?
        // 这里就是用来更新tail指针的
        else {
            if (p != t) {                 // update if slack now >= 2
                while ((tail != t || !casTail(t, s)) &&
                            (t = tail)   != null &&
                            (s = t.next) != null && // advance and retry
                            (s = s.next) != null && s != t);
            }
            return p;   // 返回p,即s的前一个元素
        }
    }
}

awaitMatch(Node s, Node pred, E e, boolean timed, long nanos) 

private E awaitMatch(Node s, Node pred, E e, boolean timed, long nanos) {
    // 如果是有超时的,计算其超时时间
    final long deadline = timed ? System.nanoTime() + nanos : 0L;
    // 当前线程
    Thread w = Thread.currentThread();
    // 自旋次数
    int spins = -1; // initialized after first item and cancel checks
    //  随机数,随机让一些自旋的线程让出CPU
    ThreadLocalRandom randomYields = null; // bound if needed

    for (;;) {
        Object item = s.item;
        // 如果s元素的值不等于e,说明它被匹配到了
        if (item != e) {                  // matched
            // assert item != s;
            // 把s的item更新为s本身
            // 并把s中的waiter置为空
            s.forgetContents();           // avoid garbage
            // 返回匹配到的元素
            return LinkedTransferQueue.cast(item);
        }

        // 如果当前线程中断了,或者有超时的到期了
        // 就更新s的元素值指向s本身
        if ((w.isInterrupted() || (timed && nanos <= 0)) &&
                s.casItem(e, s)) {        // cancel
            // 尝试解除s与其前一个节点的关系
            // 也就是删除s节点
            unsplice(pred, s);
            // 返回元素的值本身,说明没匹配到
            return e;
        }

        // 如果自旋次数小于0,就计算自旋次数
        if (spins < 0) {                  // establish spins at/near front
            // spinsFor()计算自旋次数
            // 如果前面有节点未被匹配就返回0
            // 如果前面有节点且正在匹配中就返回一定的次数,等待
            if ((spins = spinsFor(pred, s.isData)) > 0)
                // 初始化随机数
                randomYields = ThreadLocalRandom.current();
        }

        // 还有自旋次数就减1,并随机让出CPU
        else if (spins > 0) {             // spin
            --spins;
            if (randomYields.nextInt(CHAINED_SPINS) == 0)
                Thread.yield();           // occasionally yield
        }

        // 更新s的waiter为当前线程
        else if (s.waiter == null) {
            s.waiter = w;                 // request unpark then recheck
        }

        // 如果有超时,计算超时时间,并阻塞一定时间
        else if (timed) {
            nanos = deadline - System.nanoTime();
            if (nanos > 0L)
                LockSupport.parkNanos(this, nanos);
        }

        // 不是超时的,直接阻塞,等待被唤醒
        // 唤醒后进入下一次循环,走第一个if的逻辑就返回匹配的元素了
        else {
            LockSupport.park(this);
        }
    }
}

这三个方法里的内容特别复杂,很大一部分代码都是在控制线程安全,各种CAS,我们这里简单描述一下大致的逻辑:

(1)来了一个元素,我们先查看队列头的节点,是否与这个元素的模式一样;

(2)如果模式不一样,就尝试让他们匹配,如果头节点被别的线程先匹配走了,就尝试与头节点的下一个节点匹配,如此一直往后,直到匹配到或到链表尾为止;

(3)如果模式一样,或者到链表尾了,就尝试入队;

(4)入队的时候有可能链表尾修改了,那就尾指针后移,再重新尝试入队,依此往复;

(5)入队成功了,就自旋或阻塞,阻塞了就等待被其它线程匹配到并唤醒;

(6)唤醒之后进入下一次循环就匹配到元素了,返回匹配到的元素;

(7)是否需要入队及阻塞有四种情况:

           a)NOW,立即返回,没有匹配到立即返回,不做入队操作 对应的方法有:poll()、tryTransfer(e)

          b)ASYNC,异步,元素入队但当前线程不会阻塞(相当于无界LinkedBlockingQueue的元素入队) 对应的方法有:add(e)、offer(e)、put(e)、offer(e, timeout, unit)

          c)SYNC,同步,元素入队后当前线程阻塞,等待被匹配到 对应的方法有:take()、transfer(e)

          d)TIMED,有超时,元素入队后等待一段时间被匹配,时间到了还没匹配到就返回元素本身 对应的方法有:poll(timeout, unit)、tryTransfer(e, timeout, unit)

 

总结

(1)LinkedTransferQueue可以看作LinkedBlockingQueue、SynchronousQueue(公平模式)、ConcurrentLinkedQueue三者的集合体;

(2)LinkedTransferQueue的实现方式是使用一种叫做双重队列的数据结构;

(3)不管是取元素还是放元素都会入队;

(4)先尝试跟头节点比较,如果二者模式不一样,就匹配它们,组成CP,然后返回对方的值;

(5)如果二者模式一样,就入队,并自旋或阻塞等待被唤醒;

(6)至于是否入队及阻塞有四种模式,NOW、ASYNC、SYNC、TIMED;

(7)LinkedTransferQueue全程都没有使用synchronized、重入锁等比较重的锁,基本是通过 自旋+CAS 实现;

(8)对于入队之后,先自旋一定次数后再调用LockSupport.park()或LockSupport.parkNanos阻塞;

 

彩蛋

LinkedTransferQueue与SynchronousQueue(公平模式)有什么异同呢?

(1)在java8中两者的实现方式基本一致,都是使用的双重队列;

(2)前者完全实现了后者,但比后者更灵活;

(3)后者不管放元素还是取元素,如果没有可匹配的元素,所在的线程都会阻塞;

(4)前者可以自己控制放元素是否需要阻塞线程,比如使用四个添加元素的方法就不会阻塞线程,只入队元素,使用transfer()会阻塞线程;

(5)取元素两者基本一样,都会阻塞等待有新的元素进入被匹配到;

 

3.7、其他方法(从这里到后面的可以不看!!!)

cast(Object item)

// 类型转换,将object转换成 queue 中节点的类型
static  E cast(Object item) {
    // assert item == null || item.getClass() != Node.class;
    return (E) item;
}

spinsFor 

// 计算自旋次数
private static int spinsFor(Node pred, boolean haveData) {
    if (MP && pred != null) {
        if (pred.isData != haveData)      // phase change
        return FRONT_SPINS + CHAINED_SPINS;
        if (pred.isMatched())             // probably at front
            return FRONT_SPINS;
        if (pred.waiter == null)          // pred apparently spinning
            return CHAINED_SPINS;
    }
    return 0;
}

succ(Node p)  

// 返回p的后继节点,或者head(如果p.next=p)
final Node succ(Node p) {
    Node next = p.next;
    return (p == next) ? head : next;
}

firstOfMode(boolean isData) 

// 返回给定模式的第一个不匹配节点,如果没有,则返回null
// 被isEmpty()、hasWaitingConsumer() 方法调用
private Node firstOfMode(boolean isData) {
    for (Node p = head; p != null; p = succ(p)) {
        if (!p.isMatched())
            return (p.isData == isData) ? p : null;
    }
    return null;
}

firstDataNode() 

final Node firstDataNode() {
    for (Node p = head; p != null;) {
        Object item = p.item;
        if (p.isData) {
            if (item != null && item != p)
                return p;
        }
        else if (item == null)
            break;
        if (p == (p = p.next))
            p = head;
    }
    return null;
}

firstDataItem() 

private E firstDataItem() {
    for (Node p = head; p != null; p = succ(p)) {
        Object item = p.item;
        if (p.isData) {
            if (item != null && item != p)
                return LinkedTransferQueue.cast(item);
        }
        else if (item == null)
            return null;
    }
    return null;
}

 peek()  

public E peek() {
    return firstDataItem();
}

 countOfMode(boolean data) 

private int countOfMode(boolean data) {
    int count = 0;
    for (Node p = head; p != null; ) {
        if (!p.isMatched()) {
            if (p.isData != data)
                return 0;
            if (++count == Integer.MAX_VALUE) // saturated
                break;
        }
        Node n = p.next;
        if (n != p)
            p = n;
        else {
            count = 0;
            p = head;
        }
    }
    return count;
}

iterator() 

public Iterator iterator() {
    return new Itr();
}

spliterator() 

public Spliterator spliterator() {
    return new LTQSpliterator(this);
}

unsplice(Node pred, Node s) 

final void unsplice(Node pred, Node s) {
    s.forgetContents(); // forget unneeded fields

    if (pred != null && pred != s && pred.next == s) {
        Node n = s.next;
        if (n == null ||
                (n != s && pred.casNext(s, n) && pred.isMatched())) {
            for (;;) {               // check if at, or could be, head
                Node h = head;
                if (h == pred || h == s || h == null)
                    return;          // at head or list empty
                if (!h.isMatched())
                    break;
                Node hn = h.next;
                if (hn == null)
                    return;          // now empty
                if (hn != h && casHead(h, hn))
                    h.forgetNext();  // advance head
            }
            if (pred.next != pred && s.next != s) { // recheck if offlist
                for (;;) {           // sweep now if enough votes
                    int v = sweepVotes;
                    if (v < SWEEP_THRESHOLD) {
                        if (casSweepVotes(v, v + 1))
                            break;
                    }
                    else if (casSweepVotes(v, 0)) {
                        sweep();
                        break;
                    }
                }
            }
        }
    }
}

sweep() 

private void sweep() {
    for (Node p = head, s, n; p != null && (s = p.next) != null; ) {
        if (!s.isMatched())
            // Unmatched nodes are never self-linked
            p = s;
        else if ((n = s.next) == null) // trailing node is pinned
            break;
        else if (s == n)    // stale
            // No need to also check for p == s, since that implies s == n
            p = head;
        else
            p.casNext(s, n);
    }
}

findAndRemove(Object e)  

/**
* Main implementation of remove(Object)
*/
private boolean findAndRemove(Object e) {
    if (e != null) {
        for (Node pred = null, p = head; p != null; ) {
            Object item = p.item;
            if (p.isData) {
                if (item != null && item != p && e.equals(item) &&
                            p.tryMatchData()) {
                    unsplice(pred, p);
                    return true;
                }
            }
            else if (item == null)
                break;
            pred = p;
            if ((p = p.next) == pred) { // stale
                pred = null;
                p = head;
            }
        }
    }
    return false;
}

drainTo(Collection c) 

public int drainTo(Collection c) {
    if (c == null)
        throw new NullPointerException();
    if (c == this)
        throw new IllegalArgumentException();
    int n = 0;
    for (E e; (e = poll()) != null;) {
        c.add(e);
        ++n;
    }
    return n;
}

drainTo(Collection c, int maxElements) 

public int drainTo(Collection c, int maxElements) {
    if (c == null)
        throw new NullPointerException();
    if (c == this)
        throw new IllegalArgumentException();
    int n = 0;
    for (E e; n < maxElements && (e = poll()) != null;) {
        c.add(e);
        ++n;
    }
    return n;
}

isEmpty() 

public boolean isEmpty() {
    for (Node p = head; p != null; p = succ(p)) {
        if (!p.isMatched())
            return !p.isData;
    }
    return true;
}

hasWaitingConsumer() 

public boolean hasWaitingConsumer() {
    return firstOfMode(false) != null;
}

size() 

public int size() {
    return countOfMode(true);
}

getWaitingConsumerCount() 

public int getWaitingConsumerCount() {
    return countOfMode(false);
}

contains(Object o) 

public boolean contains(Object o) {
    if (o == null) 
        return false;
    for (Node p = head; p != null; p = succ(p)) {
        Object item = p.item;
        if (p.isData) {
            if (item != null && item != p && o.equals(item))
                return true;
        }
        else if (item == null)
            break;
    }
    return false;
}

remainingCapacity() 

public int remainingCapacity() {
    return Integer.MAX_VALUE;
}

 

4、内部类

4.1、Node 类

static final class Node {
    final boolean isData;   // 表示存放数据还是获取数据
    volatile Object item;   // 存放数据是item有值
    volatile Node next;     // next节点
    volatile Thread waiter; // 等待线程,不等时为null

    // CAS methods for fields
    final boolean casNext(Node cmp, Node val) {
        return UNSAFE.compareAndSwapObject(this, nextOffset, cmp, val);
    }

    final boolean casItem(Object cmp, Object val) {
        // assert cmp == null || cmp.getClass() != Node.class;
        return UNSAFE.compareAndSwapObject(this, itemOffset, cmp, val);
    }

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

        /**
         * Links node to itself to avoid garbage retention.  Called
         * only after CASing head field, so uses relaxed write.
         */
    final void forgetNext() {
        UNSAFE.putObject(this, nextOffset, this);
    }

    final void forgetContents() {
        UNSAFE.putObject(this, itemOffset, this);
        UNSAFE.putObject(this, waiterOffset, null);
    }

    final boolean isMatched() {
        Object x = item;
        return (x == this) || ((x == null) == isData);
    }

    final boolean isUnmatchedRequest() {
        return !isData && item == null;
    }

    final boolean cannotPrecede(boolean haveData) {
        boolean d = isData;
        Object x;
        return d != haveData && (x = item) != this && (x != null) == d;
    }

    final boolean tryMatchData() {
        // assert isData;
        Object x = item;
        if (x != null && x != this && casItem(x, null)) {
            LockSupport.unpark(waiter);
            return true;
        }
        return false;
    }

    private static final long serialVersionUID = -3375979862319811754L;

    // Unsafe mechanics
    private static final sun.misc.Unsafe UNSAFE;
    private static final long itemOffset;
    private static final long nextOffset;
    private static final long waiterOffset;
    static {
        try {
            UNSAFE = sun.misc.Unsafe.getUnsafe();
            Class k = Node.class;
            itemOffset = UNSAFE.objectFieldOffset(k.getDeclaredField("item"));
            nextOffset = UNSAFE.objectFieldOffset(k.getDeclaredField("next"));
            waiterOffset = UNSAFE.objectFieldOffset(k.getDeclaredField("waiter"));
        } catch (Exception e) {
            throw new Error(e);
        }
    }
}

 

4.2、Itr 类

4.3、LTQSpliterator 类

你可能感兴趣的:(JDK8,Java中的集合框架,数据结构)