java.util.concurrent.ConcurrentLinkedDeque#addFirst ( )源码实例Demo

/**
 * addFirst(null) throws NPE
 */
public void testAddFirstNull() {
    ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
    try {
        q.addFirst(null);
        shouldThrow();
    } catch (NullPointerException success) {}
}
 

/**
 * addFirst(x) succeeds
 */
public void testAddFirst() {
    ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
    q.addFirst(zero);
    q.addFirst(one);
    assertSame(one, q.peekFirst());
    assertSame(zero, q.peekLast());
}
 

/**
 * addFirst(null) throws NPE
 */
public void testAddFirstNull() {
    ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
    try {
        q.addFirst(null);
        shouldThrow();
    } catch (NullPointerException success) {}
}
 

/**
 * addFirst(x) succeeds
 */
public void testAddFirst() {
    ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
    q.addFirst(zero);
    q.addFirst(one);
    assertSame(one, q.peekFirst());
    assertSame(zero, q.peekLast());
}
 

private void maybeOffload(CompletableFuture<PositionImpl> finalPromise) {
    if (!offloadMutex.tryLock()) {
        scheduledExecutor.schedule(safeRun(() -> maybeOffloadInBackground(finalPromise)),
                                   100, TimeUnit.MILLISECONDS);
    } else {
        CompletableFuture<PositionImpl> unlockingPromise = new CompletableFuture<>();
        unlockingPromise.whenComplete((res, ex) -> {
                offloadMutex.unlock();
                if (ex != null) {
                    finalPromise.completeExceptionally(ex);
                } else {
                    finalPromise.complete(res);
                }
            });

        if (config.getLedgerOffloader() != null && config.getLedgerOffloader() != NullLedgerOffloader.INSTANCE
                && config.getLedgerOffloader().getOffloadPolicies() != null) {
            long threshold = config.getLedgerOffloader().getOffloadPolicies().getManagedLedgerOffloadThresholdInBytes();

            long sizeSummed = 0;
            long alreadyOffloadedSize = 0;
            long toOffloadSize = 0;

            ConcurrentLinkedDeque<LedgerInfo> toOffload = new ConcurrentLinkedDeque<>();

            // go through ledger list from newest to oldest and build a list to offload in oldest to newest order
            for (Map.Entry<Long, LedgerInfo> e : ledgers.descendingMap().entrySet()) {
                long size = e.getValue().getSize();
                sizeSummed += size;
                boolean alreadyOffloaded = e.getValue().hasOffloadContext()
                        && e.getValue().getOffloadContext().getComplete();
                if (alreadyOffloaded) {
                    alreadyOffloadedSize += size;
                } else if (sizeSummed > threshold) {
                    toOffloadSize += size;
                    toOffload.addFirst(e.getValue());
                }
            }

            if (toOffload.size() > 0) {
                log.info("[{}] Going to automatically offload ledgers {}"
                                + ", total size = {}, already offloaded = {}, to offload = {}",
                        name, toOffload.stream().map(LedgerInfo::getLedgerId).collect(Collectors.toList()),
                        sizeSummed, alreadyOffloadedSize, toOffloadSize);
            } else {
                // offloadLoop will complete immediately with an empty list to offload
                log.debug("[{}] Nothing to offload, total size = {}, already offloaded = {}, threshold = {}",
                        name, sizeSummed, alreadyOffloadedSize, threshold);
            }

            offloadLoop(unlockingPromise, toOffload, PositionImpl.latest, Optional.empty());
        }
    }
}