Java DelayQueue.put方法代碼示例

import java.util.concurrent.DelayQueue; //導入方法依賴的package包/類
/**
 * Execute the task and if reschedule another execution.
 *
 * @param queue
 *     Queue for the pool. This task will be added to the queue to schedule
 *     future executions.
 * @param stats
 *     Handle to stats that should be updated based on the execution of the
 *     task.
 */
@SuppressWarnings("PMD.AvoidCatchingThrowable")
void runAndReschedule(DelayQueue<DelayedTask> queue, Stats stats) {
  thread = Thread.currentThread();
  boolean scheduleAgain = options.schedulingPolicy != Policy.RUN_ONCE;
  try {
    if (!isDone()) {
      task.run();
    }
  } catch (Throwable t) {
    // This catches Throwable because we cannot control the task and thus cannot
    // ensure it is well behaved with respect to exceptions.
    LOGGER.warn("task execution failed", t);
    stats.incrementUncaught(t);
    scheduleAgain = !options.stopOnFailure;
  } finally {
    thread = null;
    if (scheduleAgain && !isDone()) {
      updateNextExecutionTime(stats.skipped());
      queue.put(this);
    } else {
      cancelled = true;
    }
  }
}
 

import java.util.concurrent.DelayQueue; //導入方法依賴的package包/類
public static void main(String[] args) throws InterruptedException {
	// TODO Auto-generated method stub
	int studentNumber = 20;
	DelayQueue<Student> students = new DelayQueue<Student>();
	Random random = new Random();
	for (int i = 0; i < studentNumber; i++) {
		students.put(new Student("student" + (i + 1), 30 + random.nextInt(120)));
	}
	students.put(new Student("student",120));
	Thread teacherThread = new Thread(new Teacher(students));
	teacherThread.start();
}
 

import java.util.concurrent.DelayQueue; //導入方法依賴的package包/類
/**
 * all elements successfully put are contained
 */
public void testPut() {
    DelayQueue q = new DelayQueue();
    for (int i = 0; i < SIZE; ++i) {
        PDelay x = new PDelay(i);
        q.put(x);
        assertTrue(q.contains(x));
    }
    assertEquals(SIZE, q.size());
}
 

import java.util.concurrent.DelayQueue; //導入方法依賴的package包/類
/**
 * drainTo empties queue
 */
public void testDrainToWithActivePut() throws InterruptedException {
    final DelayQueue q = populatedQueue(SIZE);
    Thread t = new Thread(new CheckedRunnable() {
        public void realRun() {
            q.put(new PDelay(SIZE + 1));
        }});

    t.start();
    ArrayList l = new ArrayList();
    q.drainTo(l);
    assertTrue(l.size() >= SIZE);
    t.join();
    assertTrue(q.size() + l.size() >= SIZE);
}
 

import java.util.concurrent.DelayQueue; //導入方法依賴的package包/類
public static void main(String[] args)
{
    Random rand = new Random(47);
    ExecutorService exec = Executors.newCachedThreadPool();
    DelayQueue<DelayedTask> queue = new DelayQueue<DelayedTask>();
    // Fill with tasks that have random delays:
    for (int i = 0; i < 20; i++)
    {
        queue.put(new DelayedTask(rand.nextInt(5000)));
    }
    // Set the stopping point
    queue.add(new DelayedTask.EndSentinel(5000, exec));
    exec.execute(new DelayedTaskConsumer(queue));
}
 

import java.util.concurrent.DelayQueue; //導入方法依賴的package包/類
public static void main(String[] args) {
	Random rand = new Random(47);
	ExecutorService exec = Executors.newCachedThreadPool();
	DelayQueue<DelayedTask> queue = new DelayQueue<DelayedTask>();
	// Fill with tasks that have random delays:
	for (int i = 0; i < 20; i++)
		queue.put(new DelayedTask(rand.nextInt(5000)));
	// Set the stopping point
	queue.add(new DelayedTask.EndSentinel(5000, exec));
	exec.execute(new DelayedTaskConsumer(queue));
}
 

import java.util.concurrent.DelayQueue; //導入方法依賴的package包/類
/**
 * 入口
 */
public static void main(String[] args) {
	Random rd = new Random(System.currentTimeMillis());
	ExecutorService es = Executors.newCachedThreadPool();

	// 初始化延遲隊列
	DelayQueue<DelayedTask> queue = new DelayQueue<DelayedTask>();
	for (int i = 0; i < 20; i++) {
		queue.add(new DelayedTask(rd.nextInt(5000)));
	}
	queue.put(new EndSentinel(5000, es));

	es.execute(new DelayedTaskConsumer(queue));
}
 

import java.util.concurrent.DelayQueue; //導入方法依賴的package包/類
public void testDelayQueue() throws InterruptedException {
    
    NDC.push("testDelayQueue");
    
    try {
    
        DelayQueue<DelayedCommand> queue = new DelayQueue<DelayedCommand>();

        DelayedCommand c1 = new DelayedCommand(50);
        DelayedCommand c2 = new DelayedCommand(100);
        DelayedCommand c3 = new DelayedCommand(150);

        queue.put(c1);
        logger.info("Queue: " + queue);

        queue.put(c2);
        
        logger.info("Queue: " + queue);
        
        queue.put(c3);
        logger.info("Queue: " + queue);

        long start = System.currentTimeMillis();

        while (!queue.isEmpty()) {

            DelayedCommand c = queue.take();

            logger.info("Running " + c);
            c.run();
        }

        logger.info(c1.getStart() - start);
        logger.info(c2.getStart() - c1.getStart());
        logger.info(c3.getStart() - c2.getStart());
        
        // VT: NOTE: Better, but still too clumsy without manipulations with
        // shared variable state.
    
    } finally {
        NDC.pop();
    }
}