Java ArrayBlockingQueue.addAll方法代码示例

import java.util.concurrent.ArrayBlockingQueue; //导入方法依赖的package包/类
private void pushEvent(ApsDvsEvent ev) {
    if(imuLagMs==0){
        heldEvent=ev;
        return;
    }
    ApsDvsEvent ne = new ApsDvsEvent();
    ne.copyFrom(ev);
    if (!eventQueue.offer(ne)) {
        // increase queue size
        ArrayBlockingQueue<ApsDvsEvent> newQueue = new ArrayBlockingQueue<ApsDvsEvent>(eventQueue.size() * 2);
        log.info("increased event queue to " + newQueue.remainingCapacity() + " events");
        newQueue.addAll(eventQueue);
        eventQueue = newQueue;
        eventQueue.offer(ne);
    };
}
 

import java.util.concurrent.ArrayBlockingQueue; //导入方法依赖的package包/类
/**
 * addAll(this) throws IllegalArgumentException
 */
public void testAddAllSelf() {
    ArrayBlockingQueue q = populatedQueue(SIZE);
    try {
        q.addAll(q);
        shouldThrow();
    } catch (IllegalArgumentException success) {}
}
 

import java.util.concurrent.ArrayBlockingQueue; //导入方法依赖的package包/类
/**
 * addAll of a collection with any null elements throws NPE after
 * possibly adding some elements
 */
public void testAddAll3() {
    ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
    Integer[] ints = new Integer[SIZE];
    for (int i = 0; i < SIZE - 1; ++i)
        ints[i] = new Integer(i);
    try {
        q.addAll(Arrays.asList(ints));
        shouldThrow();
    } catch (NullPointerException success) {}
}
 

import java.util.concurrent.ArrayBlockingQueue; //导入方法依赖的package包/类
/**
 * addAll throws IllegalStateException if not enough room
 */
public void testAddAll_insufficientSpace() {
    int size = ThreadLocalRandom.current().nextInt(1, SIZE);
    ArrayBlockingQueue q = populatedQueue(0, size, size, false);
    // Just fits:
    q.addAll(populatedQueue(size, size, 2 * size, false));
    assertEquals(0, q.remainingCapacity());
    assertEquals(size, q.size());
    assertEquals(0, q.peek());
    try {
        q = populatedQueue(0, size, size, false);
        q.addAll(Collections.nCopies(size + 1, 42));
        shouldThrow();
    } catch (IllegalStateException success) {}
}
 

import java.util.concurrent.ArrayBlockingQueue; //导入方法依赖的package包/类
void run() throws Throwable {
//         System.out.printf(
//             "iterations=%d size=%d, warmup=%1g, filter=\"%s\"%n",
//             iterations, size, warmupSeconds, filter);

        final ArrayList<Integer> al = new ArrayList<>(size);

        // Populate collections with random data
        final ThreadLocalRandom rnd = ThreadLocalRandom.current();
        for (int i = 0; i < size; i++)
            al.add(rnd.nextInt(size));

        final ArrayDeque<Integer> ad = new ArrayDeque<>(al);
        final ArrayBlockingQueue<Integer> abq = new ArrayBlockingQueue<>(al.size());
        abq.addAll(al);

        // shuffle circular array elements so they wrap
        for (int i = 0, n = rnd.nextInt(size); i < n; i++) {
            ad.addLast(ad.removeFirst());
            abq.add(abq.remove());
        }

        ArrayList<Job> jobs = new ArrayList<>(Arrays.asList());

        List.of(al, ad, abq,
                new LinkedList<>(al),
                new PriorityQueue<>(al),
                new Vector<>(al),
                new ConcurrentLinkedQueue<>(al),
                new ConcurrentLinkedDeque<>(al),
                new LinkedBlockingQueue<>(al),
                new LinkedBlockingDeque<>(al),
                new LinkedTransferQueue<>(al),
                new PriorityBlockingQueue<>(al))
            .stream()
            .forEach(x -> {
                         jobs.addAll(collectionJobs(x));
                         if (x instanceof Deque)
                             jobs.addAll(dequeJobs((Deque<Integer>)x));
                     });

        if (reverse) Collections.reverse(jobs);
        if (shuffle) Collections.shuffle(jobs);

        time(filter(filter, jobs));
    }