ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/ScheduledExecutorTest.java
(Generate patch)

Comparing jsr166/src/test/tck/ScheduledExecutorTest.java (file contents):
Revision 1.62 by jsr166, Sun Oct 4 08:07:31 2015 UTC vs.
Revision 1.87 by jsr166, Sat Mar 25 23:35:15 2017 UTC

# Line 7 | Line 7
7   */
8  
9   import static java.util.concurrent.TimeUnit.MILLISECONDS;
10 + import static java.util.concurrent.TimeUnit.NANOSECONDS;
11   import static java.util.concurrent.TimeUnit.SECONDS;
12  
13   import java.util.ArrayList;
# Line 17 | Line 18 | import java.util.concurrent.Callable;
18   import java.util.concurrent.CancellationException;
19   import java.util.concurrent.CountDownLatch;
20   import java.util.concurrent.ExecutionException;
20 import java.util.concurrent.Executors;
21   import java.util.concurrent.ExecutorService;
22   import java.util.concurrent.Future;
23   import java.util.concurrent.RejectedExecutionException;
# Line 25 | Line 25 | import java.util.concurrent.ScheduledFut
25   import java.util.concurrent.ScheduledThreadPoolExecutor;
26   import java.util.concurrent.ThreadFactory;
27   import java.util.concurrent.ThreadPoolExecutor;
28 + import java.util.concurrent.atomic.AtomicBoolean;
29   import java.util.concurrent.atomic.AtomicInteger;
30 + import java.util.concurrent.atomic.AtomicLong;
31  
32   import junit.framework.Test;
33   import junit.framework.TestSuite;
# Line 42 | Line 44 | public class ScheduledExecutorTest exten
44       * execute successfully executes a runnable
45       */
46      public void testExecute() throws InterruptedException {
47 <        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
47 >        final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
48          try (PoolCleaner cleaner = cleaner(p)) {
49              final CountDownLatch done = new CountDownLatch(1);
50              final Runnable task = new CheckedRunnable() {
51                  public void realRun() { done.countDown(); }};
52              p.execute(task);
53 <            assertTrue(done.await(SMALL_DELAY_MS, MILLISECONDS));
53 >            await(done);
54          }
55      }
56  
# Line 56 | Line 58 | public class ScheduledExecutorTest exten
58       * delayed schedule of callable successfully executes after delay
59       */
60      public void testSchedule1() throws Exception {
61 <        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
61 >        final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
62          try (PoolCleaner cleaner = cleaner(p)) {
63              final long startTime = System.nanoTime();
64              final CountDownLatch done = new CountDownLatch(1);
# Line 77 | Line 79 | public class ScheduledExecutorTest exten
79       * delayed schedule of runnable successfully executes after delay
80       */
81      public void testSchedule3() throws Exception {
82 <        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
82 >        final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
83          try (PoolCleaner cleaner = cleaner(p)) {
84              final long startTime = System.nanoTime();
85              final CountDownLatch done = new CountDownLatch(1);
# Line 97 | Line 99 | public class ScheduledExecutorTest exten
99       * scheduleAtFixedRate executes runnable after given initial delay
100       */
101      public void testSchedule4() throws Exception {
102 <        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
102 >        final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
103          try (PoolCleaner cleaner = cleaner(p)) {
104              final long startTime = System.nanoTime();
105              final CountDownLatch done = new CountDownLatch(1);
# Line 119 | Line 121 | public class ScheduledExecutorTest exten
121       * scheduleWithFixedDelay executes runnable after given initial delay
122       */
123      public void testSchedule5() throws Exception {
124 <        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
124 >        final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
125          try (PoolCleaner cleaner = cleaner(p)) {
126              final long startTime = System.nanoTime();
127              final CountDownLatch done = new CountDownLatch(1);
# Line 143 | Line 145 | public class ScheduledExecutorTest exten
145      }
146  
147      /**
148 <     * scheduleAtFixedRate executes series of tasks at given rate
148 >     * scheduleAtFixedRate executes series of tasks at given rate.
149 >     * Eventually, it must hold that:
150 >     *   cycles - 1 <= elapsedMillis/delay < cycles
151       */
152      public void testFixedRateSequence() throws InterruptedException {
153 <        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
153 >        final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
154          try (PoolCleaner cleaner = cleaner(p)) {
155              for (int delay = 1; delay <= LONG_DELAY_MS; delay *= 3) {
156 <                long startTime = System.nanoTime();
157 <                int cycles = 10;
156 >                final long startTime = System.nanoTime();
157 >                final int cycles = 8;
158                  final CountDownLatch done = new CountDownLatch(cycles);
159 <                Runnable task = new CheckedRunnable() {
159 >                final Runnable task = new CheckedRunnable() {
160                      public void realRun() { done.countDown(); }};
161 <                ScheduledFuture h =
161 >                final ScheduledFuture periodicTask =
162                      p.scheduleAtFixedRate(task, 0, delay, MILLISECONDS);
163 <                done.await();
164 <                h.cancel(true);
165 <                double normalizedTime =
166 <                    (double) millisElapsedSince(startTime) / delay;
167 <                if (normalizedTime >= cycles - 1 &&
168 <                    normalizedTime <= cycles)
163 >                final int totalDelayMillis = (cycles - 1) * delay;
164 >                await(done, totalDelayMillis + LONG_DELAY_MS);
165 >                periodicTask.cancel(true);
166 >                final long elapsedMillis = millisElapsedSince(startTime);
167 >                assertTrue(elapsedMillis >= totalDelayMillis);
168 >                if (elapsedMillis <= cycles * delay)
169                      return;
170 +                // else retry with longer delay
171              }
172 <            throw new AssertionError("unexpected execution rate");
172 >            fail("unexpected execution rate");
173          }
174      }
175  
176      /**
177 <     * scheduleWithFixedDelay executes series of tasks with given period
177 >     * scheduleWithFixedDelay executes series of tasks with given period.
178 >     * Eventually, it must hold that each task starts at least delay and at
179 >     * most 2 * delay after the termination of the previous task.
180       */
181      public void testFixedDelaySequence() throws InterruptedException {
182 <        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
182 >        final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
183          try (PoolCleaner cleaner = cleaner(p)) {
184              for (int delay = 1; delay <= LONG_DELAY_MS; delay *= 3) {
185 <                long startTime = System.nanoTime();
186 <                int cycles = 10;
185 >                final long startTime = System.nanoTime();
186 >                final AtomicLong previous = new AtomicLong(startTime);
187 >                final AtomicBoolean tryLongerDelay = new AtomicBoolean(false);
188 >                final int cycles = 8;
189                  final CountDownLatch done = new CountDownLatch(cycles);
190 <                Runnable task = new CheckedRunnable() {
191 <                    public void realRun() { done.countDown(); }};
192 <                ScheduledFuture h =
190 >                final int d = delay;
191 >                final Runnable task = new CheckedRunnable() {
192 >                    public void realRun() {
193 >                        long now = System.nanoTime();
194 >                        long elapsedMillis
195 >                            = NANOSECONDS.toMillis(now - previous.get());
196 >                        if (done.getCount() == cycles) { // first execution
197 >                            if (elapsedMillis >= d)
198 >                                tryLongerDelay.set(true);
199 >                        } else {
200 >                            assertTrue(elapsedMillis >= d);
201 >                            if (elapsedMillis >= 2 * d)
202 >                                tryLongerDelay.set(true);
203 >                        }
204 >                        previous.set(now);
205 >                        done.countDown();
206 >                    }};
207 >                final ScheduledFuture periodicTask =
208                      p.scheduleWithFixedDelay(task, 0, delay, MILLISECONDS);
209 <                done.await();
210 <                h.cancel(true);
211 <                double normalizedTime =
212 <                    (double) millisElapsedSince(startTime) / delay;
213 <                if (normalizedTime >= cycles - 1 &&
214 <                    normalizedTime <= cycles)
209 >                final int totalDelayMillis = (cycles - 1) * delay;
210 >                await(done, totalDelayMillis + cycles * LONG_DELAY_MS);
211 >                periodicTask.cancel(true);
212 >                final long elapsedMillis = millisElapsedSince(startTime);
213 >                assertTrue(elapsedMillis >= totalDelayMillis);
214 >                if (!tryLongerDelay.get())
215                      return;
216 +                // else retry with longer delay
217              }
218 <            throw new AssertionError("unexpected execution rate");
218 >            fail("unexpected execution rate");
219          }
220      }
221  
# Line 198 | Line 223 | public class ScheduledExecutorTest exten
223       * execute(null) throws NPE
224       */
225      public void testExecuteNull() throws InterruptedException {
226 <        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
226 >        final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
227          try (PoolCleaner cleaner = cleaner(p)) {
228              try {
229                  p.execute(null);
# Line 225 | Line 250 | public class ScheduledExecutorTest exten
250       * execute throws RejectedExecutionException if shutdown
251       */
252      public void testSchedule1_RejectedExecutionException() throws InterruptedException {
253 <        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
253 >        final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
254          try (PoolCleaner cleaner = cleaner(p)) {
255              try {
256                  p.shutdown();
# Line 241 | Line 266 | public class ScheduledExecutorTest exten
266       * schedule throws RejectedExecutionException if shutdown
267       */
268      public void testSchedule2_RejectedExecutionException() throws InterruptedException {
269 <        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
269 >        final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
270          try (PoolCleaner cleaner = cleaner(p)) {
271              try {
272                  p.shutdown();
# Line 257 | Line 282 | public class ScheduledExecutorTest exten
282       * schedule callable throws RejectedExecutionException if shutdown
283       */
284      public void testSchedule3_RejectedExecutionException() throws InterruptedException {
285 <        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
285 >        final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
286          try (PoolCleaner cleaner = cleaner(p)) {
287              try {
288                  p.shutdown();
# Line 273 | Line 298 | public class ScheduledExecutorTest exten
298       * scheduleAtFixedRate throws RejectedExecutionException if shutdown
299       */
300      public void testScheduleAtFixedRate1_RejectedExecutionException() throws InterruptedException {
301 <        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
301 >        final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
302          try (PoolCleaner cleaner = cleaner(p)) {
303              try {
304                  p.shutdown();
# Line 289 | Line 314 | public class ScheduledExecutorTest exten
314       * scheduleWithFixedDelay throws RejectedExecutionException if shutdown
315       */
316      public void testScheduleWithFixedDelay1_RejectedExecutionException() throws InterruptedException {
317 <        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
317 >        final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
318          try (PoolCleaner cleaner = cleaner(p)) {
319              try {
320                  p.shutdown();
# Line 306 | Line 331 | public class ScheduledExecutorTest exten
331       * thread becomes active
332       */
333      public void testGetActiveCount() throws InterruptedException {
334 +        final CountDownLatch done = new CountDownLatch(1);
335          final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(2);
336 <        try (PoolCleaner cleaner = cleaner(p)) {
336 >        try (PoolCleaner cleaner = cleaner(p, done)) {
337              final CountDownLatch threadStarted = new CountDownLatch(1);
312            final CountDownLatch done = new CountDownLatch(1);
338              assertEquals(0, p.getActiveCount());
339              p.execute(new CheckedRunnable() {
340                  public void realRun() throws InterruptedException {
341                      threadStarted.countDown();
342                      assertEquals(1, p.getActiveCount());
343 <                    done.await();
343 >                    await(done);
344                  }});
345 <            assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
345 >            await(threadStarted);
346              assertEquals(1, p.getActiveCount());
322            done.countDown();
347          }
348      }
349  
# Line 338 | Line 362 | public class ScheduledExecutorTest exten
362                  public void realRun() throws InterruptedException {
363                      threadStarted.countDown();
364                      assertEquals(0, p.getCompletedTaskCount());
365 <                    threadProceed.await();
365 >                    await(threadProceed);
366                      threadDone.countDown();
367                  }});
368              await(threadStarted);
369              assertEquals(0, p.getCompletedTaskCount());
370              threadProceed.countDown();
371 <            threadDone.await();
371 >            await(threadDone);
372              long startTime = System.nanoTime();
373              while (p.getCompletedTaskCount() != 1) {
374                  if (millisElapsedSince(startTime) > LONG_DELAY_MS)
# Line 373 | Line 397 | public class ScheduledExecutorTest exten
397          final ThreadPoolExecutor p = new ScheduledThreadPoolExecutor(THREADS);
398          final CountDownLatch threadsStarted = new CountDownLatch(THREADS);
399          final CountDownLatch done = new CountDownLatch(1);
400 <        try (PoolCleaner cleaner = cleaner(p)) {
400 >        try (PoolCleaner cleaner = cleaner(p, done)) {
401              assertEquals(0, p.getLargestPoolSize());
402              for (int i = 0; i < THREADS; i++)
403                  p.execute(new CheckedRunnable() {
404                      public void realRun() throws InterruptedException {
405                          threadsStarted.countDown();
406 <                        done.await();
406 >                        await(done);
407                          assertEquals(THREADS, p.getLargestPoolSize());
408                      }});
409 <            assertTrue(threadsStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
409 >            await(threadsStarted);
410              assertEquals(THREADS, p.getLargestPoolSize());
387            done.countDown();
411          }
412          assertEquals(THREADS, p.getLargestPoolSize());
413      }
# Line 397 | Line 420 | public class ScheduledExecutorTest exten
420          final ThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
421          final CountDownLatch threadStarted = new CountDownLatch(1);
422          final CountDownLatch done = new CountDownLatch(1);
423 <        try (PoolCleaner cleaner = cleaner(p)) {
423 >        try (PoolCleaner cleaner = cleaner(p, done)) {
424              assertEquals(0, p.getPoolSize());
425              p.execute(new CheckedRunnable() {
426                  public void realRun() throws InterruptedException {
427                      threadStarted.countDown();
428                      assertEquals(1, p.getPoolSize());
429 <                    done.await();
429 >                    await(done);
430                  }});
431 <            assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
431 >            await(threadStarted);
432              assertEquals(1, p.getPoolSize());
410            done.countDown();
433          }
434      }
435  
# Line 416 | Line 438 | public class ScheduledExecutorTest exten
438       * submitted
439       */
440      public void testGetTaskCount() throws InterruptedException {
441 +        final int TASKS = 3;
442 +        final CountDownLatch done = new CountDownLatch(1);
443          final ThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
444 <        try (PoolCleaner cleaner = cleaner(p)) {
444 >        try (PoolCleaner cleaner = cleaner(p, done)) {
445              final CountDownLatch threadStarted = new CountDownLatch(1);
422            final CountDownLatch done = new CountDownLatch(1);
423            final int TASKS = 5;
446              assertEquals(0, p.getTaskCount());
447 <            for (int i = 0; i < TASKS; i++)
447 >            assertEquals(0, p.getCompletedTaskCount());
448 >            p.execute(new CheckedRunnable() {
449 >                public void realRun() throws InterruptedException {
450 >                    threadStarted.countDown();
451 >                    await(done);
452 >                }});
453 >            await(threadStarted);
454 >            assertEquals(1, p.getTaskCount());
455 >            assertEquals(0, p.getCompletedTaskCount());
456 >            for (int i = 0; i < TASKS; i++) {
457 >                assertEquals(1 + i, p.getTaskCount());
458                  p.execute(new CheckedRunnable() {
459                      public void realRun() throws InterruptedException {
460                          threadStarted.countDown();
461 <                        done.await();
461 >                        assertEquals(1 + TASKS, p.getTaskCount());
462 >                        await(done);
463                      }});
464 <            assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
465 <            assertEquals(TASKS, p.getTaskCount());
466 <            done.countDown();
464 >            }
465 >            assertEquals(1 + TASKS, p.getTaskCount());
466 >            assertEquals(0, p.getCompletedTaskCount());
467          }
468 +        assertEquals(1 + TASKS, p.getTaskCount());
469 +        assertEquals(1 + TASKS, p.getCompletedTaskCount());
470      }
471  
472      /**
473       * getThreadFactory returns factory in constructor if not set
474       */
475      public void testGetThreadFactory() throws InterruptedException {
476 <        ThreadFactory threadFactory = new SimpleThreadFactory();
477 <        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1, threadFactory);
478 <        assertSame(threadFactory, p.getThreadFactory());
479 <        joinPool(p);
476 >        final ThreadFactory threadFactory = new SimpleThreadFactory();
477 >        final ScheduledThreadPoolExecutor p =
478 >            new ScheduledThreadPoolExecutor(1, threadFactory);
479 >        try (PoolCleaner cleaner = cleaner(p)) {
480 >            assertSame(threadFactory, p.getThreadFactory());
481 >        }
482      }
483  
484      /**
# Line 449 | Line 486 | public class ScheduledExecutorTest exten
486       */
487      public void testSetThreadFactory() throws InterruptedException {
488          ThreadFactory threadFactory = new SimpleThreadFactory();
489 <        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
489 >        final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
490          try (PoolCleaner cleaner = cleaner(p)) {
491              p.setThreadFactory(threadFactory);
492              assertSame(threadFactory, p.getThreadFactory());
# Line 460 | Line 497 | public class ScheduledExecutorTest exten
497       * setThreadFactory(null) throws NPE
498       */
499      public void testSetThreadFactoryNull() throws InterruptedException {
500 <        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
500 >        final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
501          try (PoolCleaner cleaner = cleaner(p)) {
502              try {
503                  p.setThreadFactory(null);
# Line 470 | Line 507 | public class ScheduledExecutorTest exten
507      }
508  
509      /**
510 +     * The default rejected execution handler is AbortPolicy.
511 +     */
512 +    public void testDefaultRejectedExecutionHandler() {
513 +        final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
514 +        try (PoolCleaner cleaner = cleaner(p)) {
515 +            assertTrue(p.getRejectedExecutionHandler()
516 +                       instanceof ThreadPoolExecutor.AbortPolicy);
517 +        }
518 +    }
519 +
520 +    /**
521       * isShutdown is false before shutdown, true after
522       */
523      public void testIsShutdown() {
524 <
525 <        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
526 <        try {
527 <            assertFalse(p.isShutdown());
528 <        }
529 <        finally {
530 <            try { p.shutdown(); } catch (SecurityException ok) { return; }
524 >        final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
525 >        assertFalse(p.isShutdown());
526 >        try (PoolCleaner cleaner = cleaner(p)) {
527 >            try {
528 >                p.shutdown();
529 >                assertTrue(p.isShutdown());
530 >            } catch (SecurityException ok) {}
531          }
484        assertTrue(p.isShutdown());
532      }
533  
534      /**
# Line 497 | Line 544 | public class ScheduledExecutorTest exten
544                  public void realRun() throws InterruptedException {
545                      assertFalse(p.isTerminated());
546                      threadStarted.countDown();
547 <                    done.await();
547 >                    await(done);
548                  }});
549 <            assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
549 >            await(threadStarted);
550              assertFalse(p.isTerminating());
551              done.countDown();
552              try { p.shutdown(); } catch (SecurityException ok) { return; }
# Line 521 | Line 568 | public class ScheduledExecutorTest exten
568                  public void realRun() throws InterruptedException {
569                      assertFalse(p.isTerminating());
570                      threadStarted.countDown();
571 <                    done.await();
571 >                    await(done);
572                  }});
573 <            assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
573 >            await(threadStarted);
574              assertFalse(p.isTerminating());
575              done.countDown();
576              try { p.shutdown(); } catch (SecurityException ok) { return; }
# Line 537 | Line 584 | public class ScheduledExecutorTest exten
584       * getQueue returns the work queue, which contains queued tasks
585       */
586      public void testGetQueue() throws InterruptedException {
587 <        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
588 <        try (PoolCleaner cleaner = cleaner(p)) {
587 >        final CountDownLatch done = new CountDownLatch(1);
588 >        final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
589 >        try (PoolCleaner cleaner = cleaner(p, done)) {
590              final CountDownLatch threadStarted = new CountDownLatch(1);
543            final CountDownLatch done = new CountDownLatch(1);
591              ScheduledFuture[] tasks = new ScheduledFuture[5];
592              for (int i = 0; i < tasks.length; i++) {
593                  Runnable r = new CheckedRunnable() {
594                      public void realRun() throws InterruptedException {
595                          threadStarted.countDown();
596 <                        done.await();
596 >                        await(done);
597                      }};
598                  tasks[i] = p.schedule(r, 1, MILLISECONDS);
599              }
600 <            assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
600 >            await(threadStarted);
601              BlockingQueue<Runnable> q = p.getQueue();
602              assertTrue(q.contains(tasks[tasks.length - 1]));
603              assertFalse(q.contains(tasks[0]));
557            done.countDown();
604          }
605      }
606  
# Line 562 | Line 608 | public class ScheduledExecutorTest exten
608       * remove(task) removes queued task, and fails to remove active task
609       */
610      public void testRemove() throws InterruptedException {
611 +        final CountDownLatch done = new CountDownLatch(1);
612          final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
613 <        try (PoolCleaner cleaner = cleaner(p)) {
613 >        try (PoolCleaner cleaner = cleaner(p, done)) {
614              ScheduledFuture[] tasks = new ScheduledFuture[5];
615              final CountDownLatch threadStarted = new CountDownLatch(1);
569            final CountDownLatch done = new CountDownLatch(1);
616              for (int i = 0; i < tasks.length; i++) {
617                  Runnable r = new CheckedRunnable() {
618                      public void realRun() throws InterruptedException {
619                          threadStarted.countDown();
620 <                        done.await();
620 >                        await(done);
621                      }};
622                  tasks[i] = p.schedule(r, 1, MILLISECONDS);
623              }
624 <            assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
624 >            await(threadStarted);
625              BlockingQueue<Runnable> q = p.getQueue();
626              assertFalse(p.remove((Runnable)tasks[0]));
627              assertTrue(q.contains((Runnable)tasks[4]));
# Line 586 | Line 632 | public class ScheduledExecutorTest exten
632              assertTrue(q.contains((Runnable)tasks[3]));
633              assertTrue(p.remove((Runnable)tasks[3]));
634              assertFalse(q.contains((Runnable)tasks[3]));
589            done.countDown();
635          }
636      }
637  
# Line 594 | Line 639 | public class ScheduledExecutorTest exten
639       * purge eventually removes cancelled tasks from the queue
640       */
641      public void testPurge() throws InterruptedException {
642 <        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
643 <        ScheduledFuture[] tasks = new ScheduledFuture[5];
644 <        for (int i = 0; i < tasks.length; i++)
645 <            tasks[i] = p.schedule(new SmallPossiblyInterruptedRunnable(),
646 <                                  LONG_DELAY_MS, MILLISECONDS);
647 <        try {
642 >        final ScheduledFuture[] tasks = new ScheduledFuture[5];
643 >        final Runnable releaser = new Runnable() { public void run() {
644 >            for (ScheduledFuture task : tasks)
645 >                if (task != null) task.cancel(true); }};
646 >        final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
647 >        try (PoolCleaner cleaner = cleaner(p, releaser)) {
648 >            for (int i = 0; i < tasks.length; i++)
649 >                tasks[i] = p.schedule(new SmallPossiblyInterruptedRunnable(),
650 >                                      LONG_DELAY_MS, MILLISECONDS);
651              int max = tasks.length;
652              if (tasks[4].cancel(true)) --max;
653              if (tasks[3].cancel(true)) --max;
# Line 611 | Line 659 | public class ScheduledExecutorTest exten
659                  long count = p.getTaskCount();
660                  if (count == max)
661                      return;
662 <            } while (millisElapsedSince(startTime) < MEDIUM_DELAY_MS);
662 >            } while (millisElapsedSince(startTime) < LONG_DELAY_MS);
663              fail("Purge failed to remove cancelled tasks");
616        } finally {
617            for (ScheduledFuture task : tasks)
618                task.cancel(true);
619            joinPool(p);
664          }
665      }
666  
# Line 630 | Line 674 | public class ScheduledExecutorTest exten
674          final AtomicInteger ran = new AtomicInteger(0);
675          final ScheduledThreadPoolExecutor p =
676              new ScheduledThreadPoolExecutor(poolSize);
677 <        CountDownLatch threadsStarted = new CountDownLatch(poolSize);
677 >        final CountDownLatch threadsStarted = new CountDownLatch(poolSize);
678          Runnable waiter = new CheckedRunnable() { public void realRun() {
679              threadsStarted.countDown();
680              try {
# Line 640 | Line 684 | public class ScheduledExecutorTest exten
684          }};
685          for (int i = 0; i < count; i++)
686              p.execute(waiter);
687 <        assertTrue(threadsStarted.await(LONG_DELAY_MS, MILLISECONDS));
687 >        await(threadsStarted);
688          assertEquals(poolSize, p.getActiveCount());
689          assertEquals(0, p.getCompletedTaskCount());
690          final List<Runnable> queuedTasks;
# Line 663 | Line 707 | public class ScheduledExecutorTest exten
707       * and those tasks are drained from the queue
708       */
709      public void testShutdownNow_delayedTasks() throws InterruptedException {
710 <        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
710 >        final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
711          List<ScheduledFuture> tasks = new ArrayList<>();
712          for (int i = 0; i < 3; i++) {
713              Runnable r = new NoOpRunnable();
# Line 700 | Line 744 | public class ScheduledExecutorTest exten
744       * - setContinueExistingPeriodicTasksAfterShutdownPolicy
745       */
746      public void testShutdown_cancellation() throws Exception {
747 <        Boolean[] allBooleans = { null, Boolean.FALSE, Boolean.TRUE };
748 <        for (Boolean policy : allBooleans)
747 >        final int UNSPECIFIED = 0, YES = 1, NO = 2;
748 >        for (int maybe : new int[] { UNSPECIFIED, YES, NO })
749      {
750          final int poolSize = 2;
751          final ScheduledThreadPoolExecutor p
752              = new ScheduledThreadPoolExecutor(poolSize);
753 <        final boolean effectiveDelayedPolicy = (policy != Boolean.FALSE);
754 <        final boolean effectivePeriodicPolicy = (policy == Boolean.TRUE);
755 <        final boolean effectiveRemovePolicy = (policy == Boolean.TRUE);
756 <        if (policy != null) {
757 <            p.setExecuteExistingDelayedTasksAfterShutdownPolicy(policy);
758 <            p.setContinueExistingPeriodicTasksAfterShutdownPolicy(policy);
759 <            p.setRemoveOnCancelPolicy(policy);
753 >        final boolean effectiveDelayedPolicy  = (maybe != NO);
754 >        final boolean effectivePeriodicPolicy = (maybe == YES);
755 >        final boolean effectiveRemovePolicy   = (maybe == YES);
756 >        if (maybe != UNSPECIFIED) {
757 >            p.setExecuteExistingDelayedTasksAfterShutdownPolicy(maybe == YES);
758 >            p.setContinueExistingPeriodicTasksAfterShutdownPolicy(maybe == YES);
759 >            p.setRemoveOnCancelPolicy(maybe == YES);
760          }
761          assertEquals(effectiveDelayedPolicy,
762                       p.getExecuteExistingDelayedTasksAfterShutdownPolicy());
# Line 729 | Line 773 | public class ScheduledExecutorTest exten
773          Runnable task = new CheckedRunnable() { public void realRun()
774                                                      throws InterruptedException {
775              poolBlocked.countDown();
776 <            assertTrue(unblock.await(LONG_DELAY_MS, MILLISECONDS));
776 >            await(unblock);
777              ran.getAndIncrement();
778          }};
779          List<Future<?>> blockers = new ArrayList<>();
# Line 737 | Line 781 | public class ScheduledExecutorTest exten
781          List<Future<?>> delayeds = new ArrayList<>();
782          for (int i = 0; i < poolSize; i++)
783              blockers.add(p.submit(task));
784 <        assertTrue(poolBlocked.await(LONG_DELAY_MS, MILLISECONDS));
784 >        await(poolBlocked);
785  
786 <        periodics.add(p.scheduleAtFixedRate(countDowner(periodicLatch1),
787 <                                            1, 1, MILLISECONDS));
788 <        periodics.add(p.scheduleWithFixedDelay(countDowner(periodicLatch2),
789 <                                               1, 1, MILLISECONDS));
786 >        periodics.add(p.scheduleAtFixedRate(
787 >                          countDowner(periodicLatch1), 1, 1, MILLISECONDS));
788 >        periodics.add(p.scheduleWithFixedDelay(
789 >                          countDowner(periodicLatch2), 1, 1, MILLISECONDS));
790          delayeds.add(p.schedule(task, 1, MILLISECONDS));
791  
792          assertTrue(p.getQueue().containsAll(periodics));
# Line 764 | Line 808 | public class ScheduledExecutorTest exten
808              assertEquals(effectiveDelayedPolicy,
809                           p.getQueue().containsAll(delayeds));
810          }
811 <        // Release all pool threads
768 <        unblock.countDown();
811 >        unblock.countDown();    // Release all pool threads
812  
813 <        for (Future<?> delayed : delayeds) {
814 <            if (effectiveDelayedPolicy) {
772 <                assertNull(delayed.get());
773 <            }
774 <        }
813 >        if (effectiveDelayedPolicy)
814 >            for (Future<?> delayed : delayeds) assertNull(delayed.get());
815          if (effectivePeriodicPolicy) {
816 <            assertTrue(periodicLatch1.await(LONG_DELAY_MS, MILLISECONDS));
817 <            assertTrue(periodicLatch2.await(LONG_DELAY_MS, MILLISECONDS));
816 >            await(periodicLatch1);
817 >            await(periodicLatch2);
818              for (Future<?> periodic : periodics) {
819                  assertTrue(periodic.cancel(false));
820                  assertTrue(periodic.isCancelled());
821                  assertTrue(periodic.isDone());
822              }
823          }
824 +        for (Future<?> blocker : blockers) assertNull(blocker.get());
825          assertTrue(p.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
826          assertTrue(p.isTerminated());
827 +
828 +        for (Future<?> future : delayeds) {
829 +            assertTrue(effectiveDelayedPolicy ^ future.isCancelled());
830 +            assertTrue(future.isDone());
831 +        }
832 +        for (Future<?> future : periodics)
833 +            assertTrue(future.isCancelled());
834 +        for (Future<?> future : blockers)
835 +            assertNull(future.get());
836          assertEquals(2 + (effectiveDelayedPolicy ? 1 : 0), ran.get());
837      }}
838  
# Line 855 | Line 905 | public class ScheduledExecutorTest exten
905          CountDownLatch latch = new CountDownLatch(1);
906          final ExecutorService e = new ScheduledThreadPoolExecutor(2);
907          try (PoolCleaner cleaner = cleaner(e)) {
908 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
908 >            List<Callable<String>> l = new ArrayList<>();
909              l.add(latchAwaitingStringTask(latch));
910              l.add(null);
911              try {
# Line 872 | Line 922 | public class ScheduledExecutorTest exten
922      public void testInvokeAny4() throws Exception {
923          final ExecutorService e = new ScheduledThreadPoolExecutor(2);
924          try (PoolCleaner cleaner = cleaner(e)) {
925 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
925 >            List<Callable<String>> l = new ArrayList<>();
926              l.add(new NPETask());
927              try {
928                  e.invokeAny(l);
# Line 889 | Line 939 | public class ScheduledExecutorTest exten
939      public void testInvokeAny5() throws Exception {
940          final ExecutorService e = new ScheduledThreadPoolExecutor(2);
941          try (PoolCleaner cleaner = cleaner(e)) {
942 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
942 >            List<Callable<String>> l = new ArrayList<>();
943              l.add(new StringTask());
944              l.add(new StringTask());
945              String result = e.invokeAny(l);
# Line 927 | Line 977 | public class ScheduledExecutorTest exten
977      public void testInvokeAll3() throws Exception {
978          final ExecutorService e = new ScheduledThreadPoolExecutor(2);
979          try (PoolCleaner cleaner = cleaner(e)) {
980 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
980 >            List<Callable<String>> l = new ArrayList<>();
981              l.add(new StringTask());
982              l.add(null);
983              try {
# Line 943 | Line 993 | public class ScheduledExecutorTest exten
993      public void testInvokeAll4() throws Exception {
994          final ExecutorService e = new ScheduledThreadPoolExecutor(2);
995          try (PoolCleaner cleaner = cleaner(e)) {
996 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
996 >            List<Callable<String>> l = new ArrayList<>();
997              l.add(new NPETask());
998              List<Future<String>> futures = e.invokeAll(l);
999              assertEquals(1, futures.size());
# Line 962 | Line 1012 | public class ScheduledExecutorTest exten
1012      public void testInvokeAll5() throws Exception {
1013          final ExecutorService e = new ScheduledThreadPoolExecutor(2);
1014          try (PoolCleaner cleaner = cleaner(e)) {
1015 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
1015 >            List<Callable<String>> l = new ArrayList<>();
1016              l.add(new StringTask());
1017              l.add(new StringTask());
1018              List<Future<String>> futures = e.invokeAll(l);
# Line 991 | Line 1041 | public class ScheduledExecutorTest exten
1041      public void testTimedInvokeAnyNullTimeUnit() throws Exception {
1042          final ExecutorService e = new ScheduledThreadPoolExecutor(2);
1043          try (PoolCleaner cleaner = cleaner(e)) {
1044 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
1044 >            List<Callable<String>> l = new ArrayList<>();
1045              l.add(new StringTask());
1046              try {
1047                  e.invokeAny(l, MEDIUM_DELAY_MS, null);
# Line 1020 | Line 1070 | public class ScheduledExecutorTest exten
1070          CountDownLatch latch = new CountDownLatch(1);
1071          final ExecutorService e = new ScheduledThreadPoolExecutor(2);
1072          try (PoolCleaner cleaner = cleaner(e)) {
1073 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
1073 >            List<Callable<String>> l = new ArrayList<>();
1074              l.add(latchAwaitingStringTask(latch));
1075              l.add(null);
1076              try {
# Line 1037 | Line 1087 | public class ScheduledExecutorTest exten
1087      public void testTimedInvokeAny4() throws Exception {
1088          final ExecutorService e = new ScheduledThreadPoolExecutor(2);
1089          try (PoolCleaner cleaner = cleaner(e)) {
1090 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
1090 >            long startTime = System.nanoTime();
1091 >            List<Callable<String>> l = new ArrayList<>();
1092              l.add(new NPETask());
1093              try {
1094 <                e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
1094 >                e.invokeAny(l, LONG_DELAY_MS, MILLISECONDS);
1095                  shouldThrow();
1096              } catch (ExecutionException success) {
1097                  assertTrue(success.getCause() instanceof NullPointerException);
1098              }
1099 +            assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1100          }
1101      }
1102  
# Line 1054 | Line 1106 | public class ScheduledExecutorTest exten
1106      public void testTimedInvokeAny5() throws Exception {
1107          final ExecutorService e = new ScheduledThreadPoolExecutor(2);
1108          try (PoolCleaner cleaner = cleaner(e)) {
1109 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
1109 >            long startTime = System.nanoTime();
1110 >            List<Callable<String>> l = new ArrayList<>();
1111              l.add(new StringTask());
1112              l.add(new StringTask());
1113 <            String result = e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
1113 >            String result = e.invokeAny(l, LONG_DELAY_MS, MILLISECONDS);
1114              assertSame(TEST_STRING, result);
1115 +            assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1116          }
1117      }
1118  
# Line 1081 | Line 1135 | public class ScheduledExecutorTest exten
1135      public void testTimedInvokeAllNullTimeUnit() throws Exception {
1136          final ExecutorService e = new ScheduledThreadPoolExecutor(2);
1137          try (PoolCleaner cleaner = cleaner(e)) {
1138 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
1138 >            List<Callable<String>> l = new ArrayList<>();
1139              l.add(new StringTask());
1140              try {
1141                  e.invokeAll(l, MEDIUM_DELAY_MS, null);
# Line 1108 | Line 1162 | public class ScheduledExecutorTest exten
1162      public void testTimedInvokeAll3() throws Exception {
1163          final ExecutorService e = new ScheduledThreadPoolExecutor(2);
1164          try (PoolCleaner cleaner = cleaner(e)) {
1165 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
1165 >            List<Callable<String>> l = new ArrayList<>();
1166              l.add(new StringTask());
1167              l.add(null);
1168              try {
# Line 1124 | Line 1178 | public class ScheduledExecutorTest exten
1178      public void testTimedInvokeAll4() throws Exception {
1179          final ExecutorService e = new ScheduledThreadPoolExecutor(2);
1180          try (PoolCleaner cleaner = cleaner(e)) {
1181 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
1181 >            List<Callable<String>> l = new ArrayList<>();
1182              l.add(new NPETask());
1183              List<Future<String>> futures =
1184 <                e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
1184 >                e.invokeAll(l, LONG_DELAY_MS, MILLISECONDS);
1185              assertEquals(1, futures.size());
1186              try {
1187                  futures.get(0).get();
# Line 1144 | Line 1198 | public class ScheduledExecutorTest exten
1198      public void testTimedInvokeAll5() throws Exception {
1199          final ExecutorService e = new ScheduledThreadPoolExecutor(2);
1200          try (PoolCleaner cleaner = cleaner(e)) {
1201 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
1201 >            List<Callable<String>> l = new ArrayList<>();
1202              l.add(new StringTask());
1203              l.add(new StringTask());
1204              List<Future<String>> futures =
# Line 1159 | Line 1213 | public class ScheduledExecutorTest exten
1213       * timed invokeAll(c) cancels tasks not completed by timeout
1214       */
1215      public void testTimedInvokeAll6() throws Exception {
1216 <        final ExecutorService e = new ScheduledThreadPoolExecutor(2);
1217 <        try (PoolCleaner cleaner = cleaner(e)) {
1218 <            for (long timeout = timeoutMillis();;) {
1216 >        for (long timeout = timeoutMillis();;) {
1217 >            final CountDownLatch done = new CountDownLatch(1);
1218 >            final Callable<String> waiter = new CheckedCallable<String>() {
1219 >                public String realCall() {
1220 >                    try { done.await(LONG_DELAY_MS, MILLISECONDS); }
1221 >                    catch (InterruptedException ok) {}
1222 >                    return "1"; }};
1223 >            final ExecutorService p = new ScheduledThreadPoolExecutor(2);
1224 >            try (PoolCleaner cleaner = cleaner(p, done)) {
1225                  List<Callable<String>> tasks = new ArrayList<>();
1226                  tasks.add(new StringTask("0"));
1227 <                tasks.add(Executors.callable(new LongPossiblyInterruptedRunnable(), TEST_STRING));
1227 >                tasks.add(waiter);
1228                  tasks.add(new StringTask("2"));
1229                  long startTime = System.nanoTime();
1230                  List<Future<String>> futures =
1231 <                    e.invokeAll(tasks, timeout, MILLISECONDS);
1231 >                    p.invokeAll(tasks, timeout, MILLISECONDS);
1232                  assertEquals(tasks.size(), futures.size());
1233                  assertTrue(millisElapsedSince(startTime) >= timeout);
1234                  for (Future future : futures)
# Line 1187 | Line 1247 | public class ScheduledExecutorTest exten
1247          }
1248      }
1249  
1250 +    /**
1251 +     * A fixed delay task with overflowing period should not prevent a
1252 +     * one-shot task from executing.
1253 +     * https://bugs.openjdk.java.net/browse/JDK-8051859
1254 +     */
1255 +    public void testScheduleWithFixedDelay_overflow() throws Exception {
1256 +        final CountDownLatch delayedDone = new CountDownLatch(1);
1257 +        final CountDownLatch immediateDone = new CountDownLatch(1);
1258 +        final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
1259 +        try (PoolCleaner cleaner = cleaner(p)) {
1260 +            final Runnable immediate = new Runnable() { public void run() {
1261 +                immediateDone.countDown();
1262 +            }};
1263 +            final Runnable delayed = new Runnable() { public void run() {
1264 +                delayedDone.countDown();
1265 +                p.submit(immediate);
1266 +            }};
1267 +            p.scheduleWithFixedDelay(delayed, 0L, Long.MAX_VALUE, SECONDS);
1268 +            await(delayedDone);
1269 +            await(immediateDone);
1270 +        }
1271 +    }
1272 +
1273   }

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines