Java ArrayBlockingQueue.remove方法代码示例

import java.util.concurrent.ArrayBlockingQueue; //导入方法依赖的package包/类
/**
 * Inserts an element in the specified queue. If the Queue is full, this
 * method removes an element from the head of the Queue and then inserts
 * the element at the tail. It can happen that the an element is removed
 * by another thread in {@link SendWorker#processMessage() processMessage}
 * method before this method attempts to remove an element from the queue.
 * This will cause {@link ArrayBlockingQueue#remove() remove} to throw an
 * exception, which is safe to ignore.
 *
 * Unlike {@link #addToRecvQueue(Message) addToRecvQueue} this method does
 * not need to be synchronized since there is only one thread that inserts
 * an element in the queue and another thread that reads from the queue.
 *
 * @param queue
 *          Reference to the Queue
 * @param buffer
 *          Reference to the buffer to be inserted in the queue
 */
private void addToSendQueue(ArrayBlockingQueue<ByteBuffer> queue,
      ByteBuffer buffer) {
    if (queue.remainingCapacity() == 0) {
        try {
            queue.remove();
        } catch (NoSuchElementException ne) {
            // element could be removed by poll()
            LOG.debug("Trying to remove from an empty " +
                    "Queue. Ignoring exception " + ne);
        }
    }
    try {
        queue.add(buffer);
    } catch (IllegalStateException ie) {
        // This should never happen
        LOG.error("Unable to insert an element in the queue " + ie);
    }
}
 

import java.util.concurrent.ArrayBlockingQueue; //导入方法依赖的package包/类
/**
 * Returns a new queue of given size containing consecutive
 * Integers 0 ... n - 1, with given capacity range and fairness.
 */
static ArrayBlockingQueue<Integer> populatedQueue(
    int size, int minCapacity, int maxCapacity, boolean fair) {
    ThreadLocalRandom rnd = ThreadLocalRandom.current();
    int capacity = rnd.nextInt(minCapacity, maxCapacity + 1);
    ArrayBlockingQueue<Integer> q = new ArrayBlockingQueue<>(capacity);
    assertTrue(q.isEmpty());
    // shuffle circular array elements so they wrap
    {
        int n = rnd.nextInt(capacity);
        for (int i = 0; i < n; i++) q.add(42);
        for (int i = 0; i < n; i++) q.remove();
    }
    for (int i = 0; i < size; i++)
        assertTrue(q.offer((Integer) i));
    assertEquals(size == 0, q.isEmpty());
    assertEquals(capacity - size, q.remainingCapacity());
    assertEquals(size, q.size());
    if (size > 0)
        assertEquals((Integer) 0, q.peek());
    return q;
}
 

import java.util.concurrent.ArrayBlockingQueue; //导入方法依赖的package包/类
/**
 * retainAll(c) retains only those elements of c and reports true if changed
 */
public void testRetainAll() {
    ArrayBlockingQueue q = populatedQueue(SIZE);
    ArrayBlockingQueue p = populatedQueue(SIZE);
    for (int i = 0; i < SIZE; ++i) {
        boolean changed = q.retainAll(p);
        if (i == 0)
            assertFalse(changed);
        else
            assertTrue(changed);

        assertTrue(q.containsAll(p));
        assertEquals(SIZE - i, q.size());
        p.remove();
    }
}
 

import java.util.concurrent.ArrayBlockingQueue; //导入方法依赖的package包/类
public String remove() {
    try {
        ArrayBlockingQueue arrayBlockingQueue = this.b0414ДД0414ДД;
        int i = bХ0425ХХ04250425;
        switch ((i * (b04250425ХХ04250425 + i)) % b0425ХХ042504250425()) {
            case 0:
                break;
            default:
                bХ0425ХХ04250425 = b0425Х0425Х04250425();
                bХ04250425Х04250425 = 94;
                break;
        }
        String str = (String) arrayBlockingQueue.remove();
        while (true) {
            switch (1) {
                case null:
                    break;
                case 1:
                    return str;
                default:
                    while (true) {
                        switch (1) {
                            case null:
                                break;
                            case 1:
                                return str;
                            default:
                        }
                    }
            }
        }
    } catch (NoSuchElementException e) {
        return null;
    }
}
 

import java.util.concurrent.ArrayBlockingQueue; //导入方法依赖的package包/类
/**
 * remove removes next element, or throws NSEE if empty
 */
public void testRemove() {
    ArrayBlockingQueue q = populatedQueue(SIZE);
    for (int i = 0; i < SIZE; ++i) {
        assertEquals(i, q.remove());
    }
    try {
        q.remove();
        shouldThrow();
    } catch (NoSuchElementException success) {}
}
 

import java.util.concurrent.ArrayBlockingQueue; //导入方法依赖的package包/类
/**
 * removeAll(c) removes only those elements of c and reports true if changed
 */
public void testRemoveAll() {
    for (int i = 1; i < SIZE; ++i) {
        ArrayBlockingQueue q = populatedQueue(SIZE);
        ArrayBlockingQueue p = populatedQueue(i);
        assertTrue(q.removeAll(p));
        assertEquals(SIZE - i, q.size());
        for (int j = 0; j < i; ++j) {
            Integer x = (Integer)(p.remove());
            assertFalse(q.contains(x));
        }
    }
}
 

import java.util.concurrent.ArrayBlockingQueue; //导入方法依赖的package包/类
/**
 * Modifications do not cause iterators to fail
 */
public void testWeaklyConsistentIteration() {
    final ArrayBlockingQueue q = new ArrayBlockingQueue(3);
    q.add(one);
    q.add(two);
    q.add(three);
    for (Iterator it = q.iterator(); it.hasNext();) {
        q.remove();
        it.next();
    }
    assertEquals(0, q.size());
}
 

import java.util.concurrent.ArrayBlockingQueue; //导入方法依赖的package包/类
/**
 * Instead of having putIndex (and takeIndex) at the initial
 * default of 0, move them to a random location.
 */
void randomizePutIndex(ArrayBlockingQueue q) {
    assertTrue(q.isEmpty());
    int capacity = q.remainingCapacity();
    int n = rnd.nextInt(capacity + 1);
    int putIndex = putIndex(q);
    for (int i = n; i-->0; ) q.add(Boolean.TRUE);
    for (int i = n; i-->0; ) q.remove();
    assertEquals(putIndex(q), (putIndex + n) % items(q).length);
}