Java Code Examples for java.lang.invoke.VarHandle#acquireFence()

SubMapIter() {
    VarHandle.acquireFence();
    Comparator<? super K> cmp = m.comparator;
    for (;;) {
        next = isDescending ? hiNode(cmp) : loNode(cmp);
        if (next == null)
            break;
        V x = next.val;
        if (x != null) {
            if (! inBounds(next.key, cmp))
                next = null;
            else
                nextValue = x;
            break;
        }
    }
}
 

/**
 * Returns an index node with key strictly less than given key.
 * Also unlinks indexes to deleted nodes found along the way.
 * Callers rely on this side-effect of clearing indices to deleted
 * nodes.
 *
 * @param key if nonnull the key
 * @return a predecessor node of key, or null if uninitialized or null key
 */
private Node<K,V> findPredecessor(Object key, Comparator<? super K> cmp) {
    Index<K,V> q;
    VarHandle.acquireFence();
    if ((q = head) == null || key == null)
        return null;
    else {
        for (Index<K,V> r, d;;) {
            while ((r = q.right) != null) {
                Node<K,V> p; K k;
                if ((p = r.node) == null || (k = p.key) == null ||
                    p.val == null)  // unlink index to deleted node
                    RIGHT.compareAndSet(q, r, r.right);
                else if (cpr(cmp, key, k) > 0)
                    q = r;
                else
                    break;
            }
            if ((d = q.down) != null)
                q = d;
            else
                return q.node;
        }
    }
}
 

/**
 * Returns an estimate of the number of worker threads that are
 * not blocked waiting to join tasks or for other managed
 * synchronization. This method may overestimate the
 * number of running threads.
 *
 * @return the number of worker threads
 */
public int getRunningThreadCount() {
    WorkQueue[] ws; WorkQueue w;
    VarHandle.acquireFence();
    int rc = 0;
    if ((ws = workQueues) != null) {
        for (int i = 1; i < ws.length; i += 2) {
            if ((w = ws[i]) != null && w.isApparentlyUnblocked())
                ++rc;
        }
    }
    return rc;
}
 

/**
 * If the lock state matches the given stamp then, atomically, if the stamp
 * represents holding a lock, releases it and returns an
 * observation stamp.  Or, if an optimistic read, returns it if
 * validated. This method returns zero in all other cases, and so
 * may be useful as a form of "tryUnlock".
 *
 * @param stamp a stamp
 * @return a valid optimistic read stamp, or zero on failure
 */
public long tryConvertToOptimisticRead(long stamp) {
    long a, m, s, next; WNode h;
    VarHandle.acquireFence();
    while (((s = state) & SBITS) == (stamp & SBITS)) {
        if ((a = stamp & ABITS) >= WBIT) {
            // write stamp
            if (s != stamp)
                break;
            return unlockWriteInternal(s);
        }
        else if (a == 0L)
            // already an optimistic read stamp
            return stamp;
        else if ((m = s & ABITS) == 0L) // invalid read stamp
            break;
        else if (m < RFULL) {
            if (casState(s, next = s - RUNIT)) {
                if (m == RUNIT && (h = whead) != null && h.status != 0)
                    release(h);
                return next & SBITS;
            }
        }
        else if ((next = tryDecReaderOverflow(s)) != 0L)
            return next & SBITS;
    }
    return 0L;
}
 

final EntrySpliterator<K,V> entrySpliterator() {
    Index<K,V> h; Node<K,V> n; long est;
    VarHandle.acquireFence();
    if ((h = head) == null) {
        n = null;
        est = 0L;
    }
    else {
        n = h.node;
        est = getAdderCount();
    }
    return new EntrySpliterator<K,V>(comparator, h, n, null, est);
}
 

final ValueSpliterator<K,V> valueSpliterator() {
    Index<K,V> h; Node<K,V> n; long est;
    VarHandle.acquireFence();
    if ((h = head) == null) {
        n = null;
        est = 0L;
    }
    else {
        n = h.node;
        est = getAdderCount();
    }
    return new ValueSpliterator<K,V>(comparator, h, n, null, est);
}
 

final KeySpliterator<K,V> keySpliterator() {
    Index<K,V> h; Node<K,V> n; long est;
    VarHandle.acquireFence();
    if ((h = head) == null) {
        n = null;
        est = 0L;
    }
    else {
        n = h.node;
        est = getAdderCount();
    }
    return new KeySpliterator<K,V>(comparator, h, n, null, est);
}
 

/**
 * Removes all of the mappings from this map.
 */
public void clear() {
    Index<K,V> h, r, d; Node<K,V> b;
    VarHandle.acquireFence();
    while ((h = head) != null) {
        if ((r = h.right) != null)        // remove indices
            RIGHT.compareAndSet(h, r, null);
        else if ((d = h.down) != null)    // remove levels
            HEAD.compareAndSet(this, h, d);
        else {
            long count = 0L;
            if ((b = h.node) != null) {    // remove nodes
                Node<K,V> n; V v;
                while ((n = b.next) != null) {
                    if ((v = n.val) != null &&
                        VAL.compareAndSet(n, v, null)) {
                        --count;
                        v = null;
                    }
                    if (v == null)
                        unlinkNode(b, n);
                }
            }
            if (count != 0L)
                addCount(count);
            else
                break;
        }
    }
}
 

/**
 * Returns {@code true} if there are any tasks submitted to this
 * pool that have not yet begun executing.
 *
 * @return {@code true} if there are any queued submissions
 */
public boolean hasQueuedSubmissions() {
    WorkQueue[] ws; WorkQueue w;
    VarHandle.acquireFence();
    if ((ws = workQueues) != null) {
        for (int i = 0; i < ws.length; i += 2) {
            if ((w = ws[i]) != null && !w.isEmpty())
                return true;
        }
    }
    return false;
}
 

/**
 * Returns an estimate of the number of tasks submitted to this
 * pool that have not yet begun executing.  This method may take
 * time proportional to the number of submissions.
 *
 * @return the number of queued submissions
 */
public int getQueuedSubmissionCount() {
    WorkQueue[] ws; WorkQueue w;
    VarHandle.acquireFence();
    int count = 0;
    if ((ws = workQueues) != null) {
        for (int i = 0; i < ws.length; i += 2) {
            if ((w = ws[i]) != null)
                count += w.queueSize();
        }
    }
    return count;
}
 

/**
 * Returns an estimate of the total number of tasks currently held
 * in queues by worker threads (but not including tasks submitted
 * to the pool that have not begun executing). This value is only
 * an approximation, obtained by iterating across all threads in
 * the pool. This method may be useful for tuning task
 * granularities.
 *
 * @return the number of queued tasks
 */
public long getQueuedTaskCount() {
    WorkQueue[] ws; WorkQueue w;
    VarHandle.acquireFence();
    int count = 0;
    if ((ws = workQueues) != null) {
        for (int i = 1; i < ws.length; i += 2) {
            if ((w = ws[i]) != null)
                count += w.queueSize();
        }
    }
    return count;
}
 

/**
 * Provides a more accurate estimate of whether this queue has
 * any tasks than does queueSize, by checking whether a
 * near-empty queue has at least one unclaimed task.
 */
final boolean isEmpty() {
    ForkJoinTask<?>[] a; int n, cap, b;
    VarHandle.acquireFence(); // needed by external callers
    return ((n = (b = base) - top) >= 0 || // possibly one task
            (n == -1 && ((a = array) == null ||
                         (cap = a.length) == 0 ||
                         a[(cap - 1) & b] == null)));
}
 

/**
 * Specialized version of find to get last valid node.
 * @return last node or null if empty
 */
final Node<K,V> findLast() {
    outer: for (;;) {
        Index<K,V> q; Node<K,V> b;
        VarHandle.acquireFence();
        if ((q = head) == null)
            break;
        for (Index<K,V> r, d;;) {
            while ((r = q.right) != null) {
                Node<K,V> p;
                if ((p = r.node) == null || p.val == null)
                    RIGHT.compareAndSet(q, r, r.right);
                else
                    q = r;
            }
            if ((d = q.down) != null)
                q = d;
            else {
                b = q.node;
                break;
            }
        }
        if (b != null) {
            for (;;) {
                Node<K,V> n;
                if ((n = b.next) == null) {
                    if (b.key == null) // empty
                        break outer;
                    else
                        return b;
                }
                else if (n.key == null)
                    break;
                else if (n.val == null)
                    unlinkNode(b, n);
                else
                    b = n;
            }
        }
    }
    return null;
}
 

/**
 * Removes last entry; returns its snapshot.
 * Specialized variant of doRemove.
 * @return null if empty, else snapshot of last entry
 */
private Map.Entry<K,V> doRemoveLastEntry() {
    outer: for (;;) {
        Index<K,V> q; Node<K,V> b;
        VarHandle.acquireFence();
        if ((q = head) == null)
            break;
        for (;;) {
            Index<K,V> d, r; Node<K,V> p;
            while ((r = q.right) != null) {
                if ((p = r.node) == null || p.val == null)
                    RIGHT.compareAndSet(q, r, r.right);
                else if (p.next != null)
                    q = r;  // continue only if a successor
                else
                    break;
            }
            if ((d = q.down) != null)
                q = d;
            else {
                b = q.node;
                break;
            }
        }
        if (b != null) {
            for (;;) {
                Node<K,V> n; K k; V v;
                if ((n = b.next) == null) {
                    if (b.key == null) // empty
                        break outer;
                    else
                        break; // retry
                }
                else if ((k = n.key) == null)
                    break;
                else if ((v = n.val) == null)
                    unlinkNode(b, n);
                else if (n.next != null)
                    b = n;
                else if (VAL.compareAndSet(n, v, null)) {
                    unlinkNode(b, n);
                    tryReduceLevel();
                    findPredecessor(k, comparator); // clean index
                    addCount(-1L);
                    return new AbstractMap.SimpleImmutableEntry<K,V>(k, v);
                }
            }
        }
    }
    return null;
}
 

/**
 * Returns the header for base node list, or null if uninitialized
 */
final Node<K,V> baseHead() {
    Index<K,V> h;
    VarHandle.acquireFence();
    return ((h = head) == null) ? null : h.node;
}
 

/**
 * Removes all available unexecuted submitted and forked tasks
 * from scheduling queues and adds them to the given collection,
 * without altering their execution status. These may include
 * artificially generated or wrapped tasks. This method is
 * designed to be invoked only when the pool is known to be
 * quiescent. Invocations at other times may not remove all
 * tasks. A failure encountered while attempting to add elements
 * to collection {@code c} may result in elements being in
 * neither, either or both collections when the associated
 * exception is thrown.  The behavior of this operation is
 * undefined if the specified collection is modified while the
 * operation is in progress.
 *
 * @param c the collection to transfer elements into
 * @return the number of elements transferred
 */
protected int drainTasksTo(Collection<? super ForkJoinTask<?>> c) {
    WorkQueue[] ws; WorkQueue w; ForkJoinTask<?> t;
    VarHandle.acquireFence();
    int count = 0;
    if ((ws = workQueues) != null) {
        for (int i = 0; i < ws.length; ++i) {
            if ((w = ws[i]) != null) {
                while ((t = w.poll()) != null) {
                    c.add(t);
                    ++count;
                }
            }
        }
    }
    return count;
}
 

/**
 * Returns true if the lock has not been exclusively acquired
 * since issuance of the given stamp. Always returns false if the
 * stamp is zero. Always returns true if the stamp represents a
 * currently held lock. Invoking this method with a value not
 * obtained from {@link #tryOptimisticRead} or a locking method
 * for this lock has no defined effect or result.
 *
 * @param stamp a stamp
 * @return {@code true} if the lock has not been exclusively acquired
 * since issuance of the given stamp; else false
 */
public boolean validate(long stamp) {
    VarHandle.acquireFence();
    return (stamp & SBITS) == (state & SBITS);
}