Java PriorityBlockingQueue.poll方法代码示例

import java.util.concurrent.PriorityBlockingQueue; //导入方法依赖的package包/类
public void testPriorityQueue() throws Exception {
    PriorityBlockingQueue<Priority> queue = new PriorityBlockingQueue<>();
    List<Priority> priorities = Arrays.asList(Priority.values());
    Collections.shuffle(priorities, random());

    for (Priority priority : priorities) {
        queue.add(priority);
    }

    Priority prevPriority = null;
    while (!queue.isEmpty()) {
        if (prevPriority == null) {
            prevPriority = queue.poll();
        } else {
            assertThat(queue.poll().after(prevPriority), is(true));
        }
    }
}
 

import java.util.concurrent.PriorityBlockingQueue; //导入方法依赖的package包/类
/**
 * drainTo(c, n) empties first min(n, size) elements of queue into c
 */
public void testDrainToN() {
    PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE * 2);
    for (int i = 0; i < SIZE + 2; ++i) {
        for (int j = 0; j < SIZE; j++)
            assertTrue(q.offer(new Integer(j)));
        ArrayList l = new ArrayList();
        q.drainTo(l, i);
        int k = (i < SIZE) ? i : SIZE;
        assertEquals(k, l.size());
        assertEquals(SIZE - k, q.size());
        for (int j = 0; j < k; ++j)
            assertEquals(l.get(j), new Integer(j));
        do {} while (q.poll() != null);
    }
}
 

import java.util.concurrent.PriorityBlockingQueue; //导入方法依赖的package包/类
/**
 * Store sensor data so that it can be published in the next publishing cycle. Unlike
 * the other log methods, this method saves the {@link #BUFFER_SIZE_FOR_ONCHANGE_SENSORS} most
 * recent sensor readings per sensor type.
 * @param data
 */
public void logSensorDataOnChange(SensorData data) {
    PriorityBlockingQueue<SensorData> newQueue =
            new PriorityBlockingQueue<SensorData>(BUFFER_SIZE_FOR_ONCHANGE_SENSORS,
                    new Comparator<SensorData>() {
        @Override
        public int compare(SensorData o1, SensorData o2) {
            return Long.compare(o1.getTimestamp(), o2.getTimestamp());
        }
    });
    PriorityBlockingQueue<SensorData> lastData = mOnChangeData.putIfAbsent(
            data.getSensorName(), newQueue);

    if (lastData == null) {
        lastData = newQueue;
    }

    // remove old entries if necessary
    while (lastData.size() >= BUFFER_SIZE_FOR_ONCHANGE_SENSORS) {
       lastData.poll();
    }

    lastData.offer(data);
}
 

import java.util.concurrent.PriorityBlockingQueue; //导入方法依赖的package包/类
/**
 * contains(x) reports true when elements added but not yet removed
 */
public void testContains() {
    PriorityBlockingQueue q = populatedQueue(SIZE);
    for (int i = 0; i < SIZE; ++i) {
        assertTrue(q.contains(new Integer(i)));
        q.poll();
        assertFalse(q.contains(new Integer(i)));
    }
}
 

import java.util.concurrent.PriorityBlockingQueue; //导入方法依赖的package包/类
/**
 * @param args
 */
public static void main(String[] args) {
	/*
	 * Priority queue to store the events
	 */
	PriorityBlockingQueue<Event> queue = new PriorityBlockingQueue<>();

	/*
	 * An array to store the five Thread objects
	 */
	Thread taskThreads[] = new Thread[5];

	/*
	 * Create the five threads to execute five tasks
	 */
	for (int i = 0; i < taskThreads.length; i++) {
		Task task = new Task(i, queue);
		taskThreads[i] = new Thread(task);
	}

	/*
	 * Start the five threads
	 */
	for (int i = 0; i < taskThreads.length; i++) {
		taskThreads[i].start();
	}

	/*
	 * Wait for the finalization of the five threads
	 */
	for (int i = 0; i < taskThreads.length; i++) {
		try {
			taskThreads[i].join();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}

	/*
	 * Write the events in the console
	 */
	System.out.printf("Main: Queue Size: %d\n", queue.size());
	for (int i = 0; i < taskThreads.length * 1000; i++) {
		Event event = queue.poll();
		System.out.printf("Thread %s: Priority %d\n", event.getThread(), event.getPriority());
	}
	System.out.printf("Main: Queue Size: %d\n", queue.size());
	System.out.printf("Main: End of the program\n");
}