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.55 by jsr166, Mon Sep 28 02:32:57 2015 UTC vs.
Revision 1.58 by jsr166, Mon Sep 28 08:23:49 2015 UTC

# Line 656 | Line 656 | public class ScheduledExecutorTest exten
656       * shutdownNow returns a list containing tasks that were not run,
657       * and those tasks are drained from the queue
658       */
659 +    public void testShutdownNow() throws InterruptedException {
660 +        final int poolSize = 2;
661 +        final int count = 5;
662 +        final AtomicInteger ran = new AtomicInteger(0);
663 +        final ScheduledThreadPoolExecutor p =
664 +            new ScheduledThreadPoolExecutor(poolSize);
665 +        CountDownLatch threadsStarted = new CountDownLatch(poolSize);
666 +        Runnable waiter = new CheckedRunnable() { public void realRun() {
667 +            threadsStarted.countDown();
668 +            try {
669 +                MILLISECONDS.sleep(2 * LONG_DELAY_MS);
670 +            } catch (InterruptedException success) {}
671 +            ran.getAndIncrement();
672 +        }};
673 +        for (int i = 0; i < count; i++)
674 +            p.execute(waiter);
675 +        assertTrue(threadsStarted.await(LONG_DELAY_MS, MILLISECONDS));
676 +        assertEquals(poolSize, p.getActiveCount());
677 +        assertEquals(0, p.getCompletedTaskCount());
678 +        final List<Runnable> queuedTasks;
679 +        try {
680 +            queuedTasks = p.shutdownNow();
681 +        } catch (SecurityException ok) {
682 +            return; // Allowed in case test doesn't have privs
683 +        }
684 +        assertTrue(p.isShutdown());
685 +        assertTrue(p.getQueue().isEmpty());
686 +        assertEquals(count - poolSize, queuedTasks.size());
687 +        assertTrue(p.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
688 +        assertTrue(p.isTerminated());
689 +        assertEquals(poolSize, ran.get());
690 +        assertEquals(poolSize, p.getCompletedTaskCount());
691 +    }
692 +
693 +    /**
694 +     * shutdownNow returns a list containing tasks that were not run,
695 +     * and those tasks are drained from the queue
696 +     */
697      public void testShutdownNow_delayedTasks() throws InterruptedException {
698          ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
699          List<ScheduledFuture> tasks = new ArrayList<>();
# Line 687 | Line 725 | public class ScheduledExecutorTest exten
725      }
726  
727      /**
728 <     * In default setting, shutdown cancels periodic but not delayed
729 <     * tasks at shutdown
728 >     * By default, periodic tasks are cancelled at shutdown.
729 >     * By default, delayed tasks keep running after shutdown.
730 >     * Check that changing the default values work:
731 >     * - setExecuteExistingDelayedTasksAfterShutdownPolicy
732 >     * - setContinueExistingPeriodicTasksAfterShutdownPolicy
733       */
734 <    public void testShutdown1() throws InterruptedException {
735 <        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
736 <        assertTrue(p.getExecuteExistingDelayedTasksAfterShutdownPolicy());
737 <        assertFalse(p.getContinueExistingPeriodicTasksAfterShutdownPolicy());
734 >    public void testShutdown_cancellation() throws Exception {
735 >        Boolean[] allBooleans = { null, Boolean.FALSE, Boolean.TRUE };
736 >        for (Boolean policy : allBooleans)
737 >    {
738 >        final int poolSize = 2;
739 >        final ScheduledThreadPoolExecutor p
740 >            = new ScheduledThreadPoolExecutor(poolSize);
741 >        final boolean effectiveDelayedPolicy = (policy != Boolean.FALSE);
742 >        final boolean effectivePeriodicPolicy = (policy == Boolean.TRUE);
743 >        final boolean effectiveRemovePolicy = (policy == Boolean.TRUE);
744 >        if (policy != null) {
745 >            p.setExecuteExistingDelayedTasksAfterShutdownPolicy(policy);
746 >            p.setContinueExistingPeriodicTasksAfterShutdownPolicy(policy);
747 >            p.setRemoveOnCancelPolicy(policy);
748 >        }
749 >        assertEquals(effectiveDelayedPolicy,
750 >                     p.getExecuteExistingDelayedTasksAfterShutdownPolicy());
751 >        assertEquals(effectivePeriodicPolicy,
752 >                     p.getContinueExistingPeriodicTasksAfterShutdownPolicy());
753 >        assertEquals(effectiveRemovePolicy,
754 >                     p.getRemoveOnCancelPolicy());
755 >        // Strategy: Wedge the pool with poolSize "blocker" threads
756 >        final AtomicInteger ran = new AtomicInteger(0);
757 >        final CountDownLatch poolBlocked = new CountDownLatch(poolSize);
758 >        final CountDownLatch unblock = new CountDownLatch(1);
759 >        final CountDownLatch periodicLatch1 = new CountDownLatch(2);
760 >        final CountDownLatch periodicLatch2 = new CountDownLatch(2);
761 >        Runnable task = new CheckedRunnable() { public void realRun()
762 >                                                    throws InterruptedException {
763 >            poolBlocked.countDown();
764 >            assertTrue(unblock.await(LONG_DELAY_MS, MILLISECONDS));
765 >            ran.getAndIncrement();
766 >        }};
767 >        List<Future<?>> blockers = new ArrayList<>();
768 >        List<Future<?>> periodics = new ArrayList<>();
769 >        List<Future<?>> delayeds = new ArrayList<>();
770 >        for (int i = 0; i < poolSize; i++)
771 >            blockers.add(p.submit(task));
772 >        assertTrue(poolBlocked.await(LONG_DELAY_MS, MILLISECONDS));
773 >
774 >        periodics.add(p.scheduleAtFixedRate(countDowner(periodicLatch1),
775 >                                            1, 1, MILLISECONDS));
776 >        periodics.add(p.scheduleWithFixedDelay(countDowner(periodicLatch2),
777 >                                               1, 1, MILLISECONDS));
778 >        delayeds.add(p.schedule(task, 1, MILLISECONDS));
779  
780 <        ScheduledFuture[] tasks = new ScheduledFuture[5];
781 <        for (int i = 0; i < tasks.length; i++)
700 <            tasks[i] = p.schedule(new NoOpRunnable(),
701 <                                  SHORT_DELAY_MS, MILLISECONDS);
780 >        assertTrue(p.getQueue().containsAll(periodics));
781 >        assertTrue(p.getQueue().containsAll(delayeds));
782          try { p.shutdown(); } catch (SecurityException ok) { return; }
703        BlockingQueue<Runnable> q = p.getQueue();
704        for (ScheduledFuture task : tasks) {
705            assertFalse(task.isDone());
706            assertFalse(task.isCancelled());
707            assertTrue(q.contains(task));
708        }
783          assertTrue(p.isShutdown());
784 <        assertTrue(p.awaitTermination(SMALL_DELAY_MS, MILLISECONDS));
785 <        assertTrue(p.isTerminated());
786 <        for (ScheduledFuture task : tasks) {
787 <            assertTrue(task.isDone());
788 <            assertFalse(task.isCancelled());
784 >        assertFalse(p.isTerminated());
785 >        for (Future<?> periodic : periodics) {
786 >            assertTrue(effectivePeriodicPolicy ^ periodic.isCancelled());
787 >            assertTrue(effectivePeriodicPolicy ^ periodic.isDone());
788 >        }
789 >        for (Future<?> delayed : delayeds) {
790 >            assertTrue(effectiveDelayedPolicy ^ delayed.isCancelled());
791 >            assertTrue(effectiveDelayedPolicy ^ delayed.isDone());
792 >        }
793 >        if (testImplementationDetails) {
794 >            assertEquals(effectivePeriodicPolicy,
795 >                         p.getQueue().containsAll(periodics));
796 >            assertEquals(effectiveDelayedPolicy,
797 >                         p.getQueue().containsAll(delayeds));
798 >        }
799 >        // Release all pool threads
800 >        unblock.countDown();
801 >
802 >        for (Future<?> delayed : delayeds) {
803 >            if (effectiveDelayedPolicy) {
804 >                assertNull(delayed.get());
805 >            }
806 >        }
807 >        if (effectivePeriodicPolicy) {
808 >            assertTrue(periodicLatch1.await(LONG_DELAY_MS, MILLISECONDS));
809 >            assertTrue(periodicLatch2.await(LONG_DELAY_MS, MILLISECONDS));
810 >            for (Future<?> periodic : periodics) {
811 >                assertTrue(periodic.cancel(false));
812 >                assertTrue(periodic.isCancelled());
813 >                assertTrue(periodic.isDone());
814 >            }
815          }
816 <    }
717 <
718 <    /**
719 <     * If setExecuteExistingDelayedTasksAfterShutdownPolicy is false,
720 <     * delayed tasks are cancelled at shutdown
721 <     */
722 <    public void testShutdown2() throws InterruptedException {
723 <        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
724 <        p.setExecuteExistingDelayedTasksAfterShutdownPolicy(false);
725 <        assertFalse(p.getExecuteExistingDelayedTasksAfterShutdownPolicy());
726 <        assertFalse(p.getContinueExistingPeriodicTasksAfterShutdownPolicy());
727 <        ScheduledFuture[] tasks = new ScheduledFuture[5];
728 <        for (int i = 0; i < tasks.length; i++)
729 <            tasks[i] = p.schedule(new NoOpRunnable(),
730 <                                  SHORT_DELAY_MS, MILLISECONDS);
731 <        BlockingQueue q = p.getQueue();
732 <        assertEquals(tasks.length, q.size());
733 <        try { p.shutdown(); } catch (SecurityException ok) { return; }
734 <        assertTrue(p.isShutdown());
735 <        assertTrue(q.isEmpty());
736 <        assertTrue(p.awaitTermination(SMALL_DELAY_MS, MILLISECONDS));
816 >        assertTrue(p.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
817          assertTrue(p.isTerminated());
818 <        for (ScheduledFuture task : tasks) {
819 <            assertTrue(task.isDone());
740 <            assertTrue(task.isCancelled());
741 <        }
742 <    }
743 <
744 <    /**
745 <     * If setContinueExistingPeriodicTasksAfterShutdownPolicy is set false,
746 <     * periodic tasks are cancelled at shutdown
747 <     */
748 <    public void testShutdown3() throws InterruptedException {
749 <        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
750 <        assertTrue(p.getExecuteExistingDelayedTasksAfterShutdownPolicy());
751 <        assertFalse(p.getContinueExistingPeriodicTasksAfterShutdownPolicy());
752 <        p.setContinueExistingPeriodicTasksAfterShutdownPolicy(false);
753 <        assertTrue(p.getExecuteExistingDelayedTasksAfterShutdownPolicy());
754 <        assertFalse(p.getContinueExistingPeriodicTasksAfterShutdownPolicy());
755 <        long initialDelay = LONG_DELAY_MS;
756 <        ScheduledFuture task =
757 <            p.scheduleAtFixedRate(new NoOpRunnable(), initialDelay,
758 <                                  5, MILLISECONDS);
759 <        try { p.shutdown(); } catch (SecurityException ok) { return; }
760 <        assertTrue(p.isShutdown());
761 <        assertTrue(p.getQueue().isEmpty());
762 <        assertTrue(task.isDone());
763 <        assertTrue(task.isCancelled());
764 <        joinPool(p);
765 <    }
766 <
767 <    /**
768 <     * if setContinueExistingPeriodicTasksAfterShutdownPolicy is true,
769 <     * periodic tasks are not cancelled at shutdown
770 <     */
771 <    public void testShutdown4() throws InterruptedException {
772 <        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
773 <        final CountDownLatch counter = new CountDownLatch(2);
774 <        try {
775 <            p.setContinueExistingPeriodicTasksAfterShutdownPolicy(true);
776 <            assertTrue(p.getExecuteExistingDelayedTasksAfterShutdownPolicy());
777 <            assertTrue(p.getContinueExistingPeriodicTasksAfterShutdownPolicy());
778 <            final Runnable r = new CheckedRunnable() {
779 <                public void realRun() {
780 <                    counter.countDown();
781 <                }};
782 <            ScheduledFuture task =
783 <                p.scheduleAtFixedRate(r, 1, 1, MILLISECONDS);
784 <            assertFalse(task.isDone());
785 <            assertFalse(task.isCancelled());
786 <            try { p.shutdown(); } catch (SecurityException ok) { return; }
787 <            assertFalse(task.isCancelled());
788 <            assertFalse(p.isTerminated());
789 <            assertTrue(p.isShutdown());
790 <            assertTrue(counter.await(SMALL_DELAY_MS, MILLISECONDS));
791 <            assertFalse(task.isCancelled());
792 <            assertTrue(task.cancel(false));
793 <            assertTrue(task.isDone());
794 <            assertTrue(task.isCancelled());
795 <            assertTrue(p.awaitTermination(SMALL_DELAY_MS, MILLISECONDS));
796 <            assertTrue(p.isTerminated());
797 <        }
798 <        finally {
799 <            joinPool(p);
800 <        }
801 <    }
818 >        assertEquals(2 + (effectiveDelayedPolicy ? 1 : 0), ran.get());
819 >    }}
820  
821      /**
822       * completed submit of callable returns result

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines