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

Comparing jsr166/src/test/tck/ThreadPoolExecutorTest.java (file contents):
Revision 1.48 by jsr166, Mon May 20 16:51:56 2013 UTC vs.
Revision 1.64 by jsr166, Mon Sep 28 21:15:44 2015 UTC

# Line 6 | Line 6
6   * Pat Fisher, Mike Judd.
7   */
8  
9 – import junit.framework.*;
10 – import java.util.concurrent.*;
9   import static java.util.concurrent.TimeUnit.MILLISECONDS;
10   import static java.util.concurrent.TimeUnit.NANOSECONDS;
11 < import java.util.*;
11 > import static java.util.concurrent.TimeUnit.SECONDS;
12 >
13 > import java.util.ArrayList;
14 > import java.util.List;
15 > import java.util.concurrent.ArrayBlockingQueue;
16 > import java.util.concurrent.BlockingQueue;
17 > import java.util.concurrent.Callable;
18 > import java.util.concurrent.CancellationException;
19 > import java.util.concurrent.CountDownLatch;
20 > import java.util.concurrent.ExecutionException;
21 > import java.util.concurrent.Executors;
22 > import java.util.concurrent.ExecutorService;
23 > import java.util.concurrent.Future;
24 > import java.util.concurrent.FutureTask;
25 > import java.util.concurrent.LinkedBlockingQueue;
26 > import java.util.concurrent.RejectedExecutionException;
27 > import java.util.concurrent.RejectedExecutionHandler;
28 > import java.util.concurrent.SynchronousQueue;
29 > import java.util.concurrent.ThreadFactory;
30 > import java.util.concurrent.ThreadPoolExecutor;
31 > import java.util.concurrent.TimeUnit;
32 > import java.util.concurrent.atomic.AtomicInteger;
33 >
34 > import junit.framework.Test;
35 > import junit.framework.TestSuite;
36  
37   public class ThreadPoolExecutorTest extends JSR166TestCase {
38      public static void main(String[] args) {
39 <        junit.textui.TestRunner.run(suite());
39 >        main(suite(), args);
40      }
41      public static Test suite() {
42          return new TestSuite(ThreadPoolExecutorTest.class);
# Line 195 | Line 217 | public class ThreadPoolExecutorTest exte
217              new ThreadPoolExecutor(2, 2,
218                                     1000, MILLISECONDS,
219                                     new ArrayBlockingQueue<Runnable>(10));
220 <        assertEquals(1, p.getKeepAliveTime(TimeUnit.SECONDS));
220 >        assertEquals(1, p.getKeepAliveTime(SECONDS));
221          joinPool(p);
222      }
223  
# Line 603 | Line 625 | public class ThreadPoolExecutorTest exte
625      }
626  
627      /**
628 <     * shutdownNow returns a list containing tasks that were not run
628 >     * shutdownNow returns a list containing tasks that were not run,
629 >     * and those tasks are drained from the queue
630       */
631 <    public void testShutdownNow() {
631 >    public void testShutdownNow() throws InterruptedException {
632 >        final int poolSize = 2;
633 >        final int count = 5;
634 >        final AtomicInteger ran = new AtomicInteger(0);
635          final ThreadPoolExecutor p =
636 <            new ThreadPoolExecutor(1, 1,
636 >            new ThreadPoolExecutor(poolSize, poolSize,
637                                     LONG_DELAY_MS, MILLISECONDS,
638                                     new ArrayBlockingQueue<Runnable>(10));
639 <        List l;
640 <        try {
641 <            for (int i = 0; i < 5; i++)
616 <                p.execute(new MediumPossiblyInterruptedRunnable());
617 <        }
618 <        finally {
639 >        CountDownLatch threadsStarted = new CountDownLatch(poolSize);
640 >        Runnable waiter = new CheckedRunnable() { public void realRun() {
641 >            threadsStarted.countDown();
642              try {
643 <                l = p.shutdownNow();
644 <            } catch (SecurityException ok) { return; }
643 >                MILLISECONDS.sleep(2 * LONG_DELAY_MS);
644 >            } catch (InterruptedException success) {}
645 >            ran.getAndIncrement();
646 >        }};
647 >        for (int i = 0; i < count; i++)
648 >            p.execute(waiter);
649 >        assertTrue(threadsStarted.await(LONG_DELAY_MS, MILLISECONDS));
650 >        assertEquals(poolSize, p.getActiveCount());
651 >        assertEquals(0, p.getCompletedTaskCount());
652 >        final List<Runnable> queuedTasks;
653 >        try {
654 >            queuedTasks = p.shutdownNow();
655 >        } catch (SecurityException ok) {
656 >            return; // Allowed in case test doesn't have privs
657          }
658          assertTrue(p.isShutdown());
659 <        assertTrue(l.size() <= 4);
659 >        assertTrue(p.getQueue().isEmpty());
660 >        assertEquals(count - poolSize, queuedTasks.size());
661 >        assertTrue(p.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
662 >        assertTrue(p.isTerminated());
663 >        assertEquals(poolSize, ran.get());
664 >        assertEquals(poolSize, p.getCompletedTaskCount());
665      }
666  
667      // Exception Tests
# Line 631 | Line 671 | public class ThreadPoolExecutorTest exte
671       */
672      public void testConstructor1() {
673          try {
674 <            new ThreadPoolExecutor(-1, 1,
635 <                                   LONG_DELAY_MS, MILLISECONDS,
674 >            new ThreadPoolExecutor(-1, 1, 1L, SECONDS,
675                                     new ArrayBlockingQueue<Runnable>(10));
676              shouldThrow();
677          } catch (IllegalArgumentException success) {}
# Line 643 | Line 682 | public class ThreadPoolExecutorTest exte
682       */
683      public void testConstructor2() {
684          try {
685 <            new ThreadPoolExecutor(1, -1,
647 <                                   LONG_DELAY_MS, MILLISECONDS,
685 >            new ThreadPoolExecutor(1, -1, 1L, SECONDS,
686                                     new ArrayBlockingQueue<Runnable>(10));
687              shouldThrow();
688          } catch (IllegalArgumentException success) {}
# Line 655 | Line 693 | public class ThreadPoolExecutorTest exte
693       */
694      public void testConstructor3() {
695          try {
696 <            new ThreadPoolExecutor(1, 0,
659 <                                   LONG_DELAY_MS, MILLISECONDS,
696 >            new ThreadPoolExecutor(1, 0, 1L, SECONDS,
697                                     new ArrayBlockingQueue<Runnable>(10));
698              shouldThrow();
699          } catch (IllegalArgumentException success) {}
# Line 667 | Line 704 | public class ThreadPoolExecutorTest exte
704       */
705      public void testConstructor4() {
706          try {
707 <            new ThreadPoolExecutor(1, 2,
671 <                                   -1L, MILLISECONDS,
707 >            new ThreadPoolExecutor(1, 2, -1L, SECONDS,
708                                     new ArrayBlockingQueue<Runnable>(10));
709              shouldThrow();
710          } catch (IllegalArgumentException success) {}
# Line 679 | Line 715 | public class ThreadPoolExecutorTest exte
715       */
716      public void testConstructor5() {
717          try {
718 <            new ThreadPoolExecutor(2, 1,
683 <                                   LONG_DELAY_MS, MILLISECONDS,
718 >            new ThreadPoolExecutor(2, 1, 1L, SECONDS,
719                                     new ArrayBlockingQueue<Runnable>(10));
720              shouldThrow();
721          } catch (IllegalArgumentException success) {}
# Line 691 | Line 726 | public class ThreadPoolExecutorTest exte
726       */
727      public void testConstructorNullPointerException() {
728          try {
729 <            new ThreadPoolExecutor(1, 2,
695 <                                   LONG_DELAY_MS, MILLISECONDS,
729 >            new ThreadPoolExecutor(1, 2, 1L, SECONDS,
730                                     (BlockingQueue) null);
731              shouldThrow();
732          } catch (NullPointerException success) {}
# Line 703 | Line 737 | public class ThreadPoolExecutorTest exte
737       */
738      public void testConstructor6() {
739          try {
740 <            new ThreadPoolExecutor(-1, 1,
707 <                                   LONG_DELAY_MS, MILLISECONDS,
740 >            new ThreadPoolExecutor(-1, 1, 1L, SECONDS,
741                                     new ArrayBlockingQueue<Runnable>(10),
742                                     new SimpleThreadFactory());
743              shouldThrow();
# Line 716 | Line 749 | public class ThreadPoolExecutorTest exte
749       */
750      public void testConstructor7() {
751          try {
752 <            new ThreadPoolExecutor(1, -1,
720 <                                   LONG_DELAY_MS, MILLISECONDS,
752 >            new ThreadPoolExecutor(1, -1, 1L, SECONDS,
753                                     new ArrayBlockingQueue<Runnable>(10),
754                                     new SimpleThreadFactory());
755              shouldThrow();
# Line 729 | Line 761 | public class ThreadPoolExecutorTest exte
761       */
762      public void testConstructor8() {
763          try {
764 <            new ThreadPoolExecutor(1, 0,
733 <                                   LONG_DELAY_MS, MILLISECONDS,
764 >            new ThreadPoolExecutor(1, 0, 1L, SECONDS,
765                                     new ArrayBlockingQueue<Runnable>(10),
766                                     new SimpleThreadFactory());
767              shouldThrow();
# Line 742 | Line 773 | public class ThreadPoolExecutorTest exte
773       */
774      public void testConstructor9() {
775          try {
776 <            new ThreadPoolExecutor(1, 2,
746 <                                   -1L, MILLISECONDS,
776 >            new ThreadPoolExecutor(1, 2, -1L, SECONDS,
777                                     new ArrayBlockingQueue<Runnable>(10),
778                                     new SimpleThreadFactory());
779              shouldThrow();
# Line 755 | Line 785 | public class ThreadPoolExecutorTest exte
785       */
786      public void testConstructor10() {
787          try {
788 <            new ThreadPoolExecutor(2, 1,
759 <                                   LONG_DELAY_MS, MILLISECONDS,
788 >            new ThreadPoolExecutor(2, 1, 1L, SECONDS,
789                                     new ArrayBlockingQueue<Runnable>(10),
790                                     new SimpleThreadFactory());
791              shouldThrow();
# Line 768 | Line 797 | public class ThreadPoolExecutorTest exte
797       */
798      public void testConstructorNullPointerException2() {
799          try {
800 <            new ThreadPoolExecutor(1, 2,
772 <                                   LONG_DELAY_MS, MILLISECONDS,
800 >            new ThreadPoolExecutor(1, 2, 1L, SECONDS,
801                                     (BlockingQueue) null,
802                                     new SimpleThreadFactory());
803              shouldThrow();
# Line 781 | Line 809 | public class ThreadPoolExecutorTest exte
809       */
810      public void testConstructorNullPointerException3() {
811          try {
812 <            new ThreadPoolExecutor(1, 2,
785 <                                   LONG_DELAY_MS, MILLISECONDS,
812 >            new ThreadPoolExecutor(1, 2, 1L, SECONDS,
813                                     new ArrayBlockingQueue<Runnable>(10),
814                                     (ThreadFactory) null);
815              shouldThrow();
# Line 794 | Line 821 | public class ThreadPoolExecutorTest exte
821       */
822      public void testConstructor11() {
823          try {
824 <            new ThreadPoolExecutor(-1, 1,
798 <                                   LONG_DELAY_MS, MILLISECONDS,
824 >            new ThreadPoolExecutor(-1, 1, 1L, SECONDS,
825                                     new ArrayBlockingQueue<Runnable>(10),
826                                     new NoOpREHandler());
827              shouldThrow();
# Line 807 | Line 833 | public class ThreadPoolExecutorTest exte
833       */
834      public void testConstructor12() {
835          try {
836 <            new ThreadPoolExecutor(1, -1,
811 <                                   LONG_DELAY_MS, MILLISECONDS,
836 >            new ThreadPoolExecutor(1, -1, 1L, SECONDS,
837                                     new ArrayBlockingQueue<Runnable>(10),
838                                     new NoOpREHandler());
839              shouldThrow();
# Line 820 | Line 845 | public class ThreadPoolExecutorTest exte
845       */
846      public void testConstructor13() {
847          try {
848 <            new ThreadPoolExecutor(1, 0,
824 <                                   LONG_DELAY_MS, MILLISECONDS,
848 >            new ThreadPoolExecutor(1, 0, 1L, SECONDS,
849                                     new ArrayBlockingQueue<Runnable>(10),
850                                     new NoOpREHandler());
851              shouldThrow();
# Line 833 | Line 857 | public class ThreadPoolExecutorTest exte
857       */
858      public void testConstructor14() {
859          try {
860 <            new ThreadPoolExecutor(1, 2,
837 <                                   -1L, MILLISECONDS,
860 >            new ThreadPoolExecutor(1, 2, -1L, SECONDS,
861                                     new ArrayBlockingQueue<Runnable>(10),
862                                     new NoOpREHandler());
863              shouldThrow();
# Line 846 | Line 869 | public class ThreadPoolExecutorTest exte
869       */
870      public void testConstructor15() {
871          try {
872 <            new ThreadPoolExecutor(2, 1,
850 <                                   LONG_DELAY_MS, MILLISECONDS,
872 >            new ThreadPoolExecutor(2, 1, 1L, SECONDS,
873                                     new ArrayBlockingQueue<Runnable>(10),
874                                     new NoOpREHandler());
875              shouldThrow();
# Line 859 | Line 881 | public class ThreadPoolExecutorTest exte
881       */
882      public void testConstructorNullPointerException4() {
883          try {
884 <            new ThreadPoolExecutor(1, 2,
863 <                                   LONG_DELAY_MS, MILLISECONDS,
884 >            new ThreadPoolExecutor(1, 2, 1L, SECONDS,
885                                     (BlockingQueue) null,
886                                     new NoOpREHandler());
887              shouldThrow();
# Line 872 | Line 893 | public class ThreadPoolExecutorTest exte
893       */
894      public void testConstructorNullPointerException5() {
895          try {
896 <            new ThreadPoolExecutor(1, 2,
876 <                                   LONG_DELAY_MS, MILLISECONDS,
896 >            new ThreadPoolExecutor(1, 2, 1L, SECONDS,
897                                     new ArrayBlockingQueue<Runnable>(10),
898                                     (RejectedExecutionHandler) null);
899              shouldThrow();
# Line 885 | Line 905 | public class ThreadPoolExecutorTest exte
905       */
906      public void testConstructor16() {
907          try {
908 <            new ThreadPoolExecutor(-1, 1,
889 <                                   LONG_DELAY_MS, MILLISECONDS,
908 >            new ThreadPoolExecutor(-1, 1, 1L, SECONDS,
909                                     new ArrayBlockingQueue<Runnable>(10),
910                                     new SimpleThreadFactory(),
911                                     new NoOpREHandler());
# Line 899 | Line 918 | public class ThreadPoolExecutorTest exte
918       */
919      public void testConstructor17() {
920          try {
921 <            new ThreadPoolExecutor(1, -1,
903 <                                   LONG_DELAY_MS, MILLISECONDS,
921 >            new ThreadPoolExecutor(1, -1, 1L, SECONDS,
922                                     new ArrayBlockingQueue<Runnable>(10),
923                                     new SimpleThreadFactory(),
924                                     new NoOpREHandler());
# Line 913 | Line 931 | public class ThreadPoolExecutorTest exte
931       */
932      public void testConstructor18() {
933          try {
934 <            new ThreadPoolExecutor(1, 0,
917 <                                   LONG_DELAY_MS, MILLISECONDS,
934 >            new ThreadPoolExecutor(1, 0, 1L, SECONDS,
935                                     new ArrayBlockingQueue<Runnable>(10),
936                                     new SimpleThreadFactory(),
937                                     new NoOpREHandler());
# Line 927 | Line 944 | public class ThreadPoolExecutorTest exte
944       */
945      public void testConstructor19() {
946          try {
947 <            new ThreadPoolExecutor(1, 2,
931 <                                   -1L, MILLISECONDS,
947 >            new ThreadPoolExecutor(1, 2, -1L, SECONDS,
948                                     new ArrayBlockingQueue<Runnable>(10),
949                                     new SimpleThreadFactory(),
950                                     new NoOpREHandler());
# Line 941 | Line 957 | public class ThreadPoolExecutorTest exte
957       */
958      public void testConstructor20() {
959          try {
960 <            new ThreadPoolExecutor(2, 1,
945 <                                   LONG_DELAY_MS, MILLISECONDS,
960 >            new ThreadPoolExecutor(2, 1, 1L, SECONDS,
961                                     new ArrayBlockingQueue<Runnable>(10),
962                                     new SimpleThreadFactory(),
963                                     new NoOpREHandler());
# Line 955 | Line 970 | public class ThreadPoolExecutorTest exte
970       */
971      public void testConstructorNullPointerException6() {
972          try {
973 <            new ThreadPoolExecutor(1, 2,
959 <                                   LONG_DELAY_MS, MILLISECONDS,
973 >            new ThreadPoolExecutor(1, 2, 1L, SECONDS,
974                                     (BlockingQueue) null,
975                                     new SimpleThreadFactory(),
976                                     new NoOpREHandler());
# Line 969 | Line 983 | public class ThreadPoolExecutorTest exte
983       */
984      public void testConstructorNullPointerException7() {
985          try {
986 <            new ThreadPoolExecutor(1, 2,
973 <                                   LONG_DELAY_MS, MILLISECONDS,
986 >            new ThreadPoolExecutor(1, 2, 1L, SECONDS,
987                                     new ArrayBlockingQueue<Runnable>(10),
988                                     new SimpleThreadFactory(),
989                                     (RejectedExecutionHandler) null);
# Line 983 | Line 996 | public class ThreadPoolExecutorTest exte
996       */
997      public void testConstructorNullPointerException8() {
998          try {
999 <            new ThreadPoolExecutor(1, 2,
987 <                                   LONG_DELAY_MS, MILLISECONDS,
999 >            new ThreadPoolExecutor(1, 2, 1L, SECONDS,
1000                                     new ArrayBlockingQueue<Runnable>(10),
1001                                     (ThreadFactory) null,
1002                                     new NoOpREHandler());
# Line 998 | Line 1010 | public class ThreadPoolExecutorTest exte
1010      public void testInterruptedSubmit() throws InterruptedException {
1011          final ThreadPoolExecutor p =
1012              new ThreadPoolExecutor(1, 1,
1013 <                                   60, TimeUnit.SECONDS,
1013 >                                   60, SECONDS,
1014                                     new ArrayBlockingQueue<Runnable>(10));
1015  
1016          final CountDownLatch threadStarted = new CountDownLatch(1);
# Line 1272 | Line 1284 | public class ThreadPoolExecutorTest exte
1284       */
1285      public void testExecuteNull() {
1286          ThreadPoolExecutor p =
1287 <            new ThreadPoolExecutor(1, 2,
1276 <                                   LONG_DELAY_MS, MILLISECONDS,
1287 >            new ThreadPoolExecutor(1, 2, 1L, SECONDS,
1288                                     new ArrayBlockingQueue<Runnable>(10));
1289          try {
1290              p.execute(null);
# Line 1340 | Line 1351 | public class ThreadPoolExecutorTest exte
1351      }
1352  
1353      /**
1354 +     * Configuration changes that allow core pool size greater than
1355 +     * max pool size result in IllegalArgumentException.
1356 +     */
1357 +    public void testPoolSizeInvariants() {
1358 +        ThreadPoolExecutor p =
1359 +            new ThreadPoolExecutor(1, 1,
1360 +                                   LONG_DELAY_MS, MILLISECONDS,
1361 +                                   new ArrayBlockingQueue<Runnable>(10));
1362 +        for (int s = 1; s < 5; s++) {
1363 +            p.setMaximumPoolSize(s);
1364 +            p.setCorePoolSize(s);
1365 +            try {
1366 +                p.setMaximumPoolSize(s - 1);
1367 +                shouldThrow();
1368 +            } catch (IllegalArgumentException success) {}
1369 +            assertEquals(s, p.getCorePoolSize());
1370 +            assertEquals(s, p.getMaximumPoolSize());
1371 +            try {
1372 +                p.setCorePoolSize(s + 1);
1373 +                shouldThrow();
1374 +            } catch (IllegalArgumentException success) {}
1375 +            assertEquals(s, p.getCorePoolSize());
1376 +            assertEquals(s, p.getMaximumPoolSize());
1377 +        }
1378 +        joinPool(p);
1379 +    }
1380 +
1381 +    /**
1382       * setKeepAliveTime throws IllegalArgumentException
1383       * when given a negative value
1384       */
# Line 1375 | Line 1414 | public class ThreadPoolExecutorTest exte
1414          ExtendedTPE p = new ExtendedTPE();
1415          try {
1416              final CountDownLatch done = new CountDownLatch(1);
1417 <            final CheckedRunnable task = new CheckedRunnable() {
1417 >            p.execute(new CheckedRunnable() {
1418                  public void realRun() {
1419                      done.countDown();
1420 <                }};
1382 <            p.execute(task);
1420 >                }});
1421              await(p.afterCalled);
1422              assertEquals(0, done.getCount());
1423              assertTrue(p.afterCalled());
# Line 1874 | Line 1912 | public class ThreadPoolExecutorTest exte
1912                                     LONG_DELAY_MS, MILLISECONDS,
1913                                     new ArrayBlockingQueue<Runnable>(10));
1914          try {
1915 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
1916 <            l.add(new StringTask());
1917 <            l.add(Executors.callable(new MediumPossiblyInterruptedRunnable(), TEST_STRING));
1918 <            l.add(new StringTask());
1919 <            List<Future<String>> futures =
1920 <                e.invokeAll(l, SHORT_DELAY_MS, MILLISECONDS);
1921 <            assertEquals(l.size(), futures.size());
1922 <            for (Future future : futures)
1923 <                assertTrue(future.isDone());
1924 <            assertFalse(futures.get(0).isCancelled());
1925 <            assertTrue(futures.get(1).isCancelled());
1915 >            for (long timeout = timeoutMillis();;) {
1916 >                List<Callable<String>> tasks = new ArrayList<>();
1917 >                tasks.add(new StringTask("0"));
1918 >                tasks.add(Executors.callable(new LongPossiblyInterruptedRunnable(), TEST_STRING));
1919 >                tasks.add(new StringTask("2"));
1920 >                long startTime = System.nanoTime();
1921 >                List<Future<String>> futures =
1922 >                    e.invokeAll(tasks, timeout, MILLISECONDS);
1923 >                assertEquals(tasks.size(), futures.size());
1924 >                assertTrue(millisElapsedSince(startTime) >= timeout);
1925 >                for (Future future : futures)
1926 >                    assertTrue(future.isDone());
1927 >                assertTrue(futures.get(1).isCancelled());
1928 >                try {
1929 >                    assertEquals("0", futures.get(0).get());
1930 >                    assertEquals("2", futures.get(2).get());
1931 >                    break;
1932 >                } catch (CancellationException retryWithLongerTimeout) {
1933 >                    timeout *= 2;
1934 >                    if (timeout >= LONG_DELAY_MS / 2)
1935 >                        fail("expected exactly one task to be cancelled");
1936 >                }
1937 >            }
1938          } finally {
1939              joinPool(e);
1940          }
# Line 1930 | Line 1980 | public class ThreadPoolExecutorTest exte
1980       * allowCoreThreadTimeOut(true) causes idle threads to time out
1981       */
1982      public void testAllowCoreThreadTimeOut_true() throws Exception {
1983 <        long coreThreadTimeOut = SHORT_DELAY_MS;
1983 >        long keepAliveTime = timeoutMillis();
1984          final ThreadPoolExecutor p =
1985              new ThreadPoolExecutor(2, 10,
1986 <                                   coreThreadTimeOut, MILLISECONDS,
1986 >                                   keepAliveTime, MILLISECONDS,
1987                                     new ArrayBlockingQueue<Runnable>(10));
1988          final CountDownLatch threadStarted = new CountDownLatch(1);
1989          try {
# Line 1944 | Line 1994 | public class ThreadPoolExecutorTest exte
1994                      assertEquals(1, p.getPoolSize());
1995                  }});
1996              await(threadStarted);
1997 <            delay(coreThreadTimeOut);
1997 >            delay(keepAliveTime);
1998              long startTime = System.nanoTime();
1999              while (p.getPoolSize() > 0
2000                     && millisElapsedSince(startTime) < LONG_DELAY_MS)
# Line 1960 | Line 2010 | public class ThreadPoolExecutorTest exte
2010       * allowCoreThreadTimeOut(false) causes idle threads not to time out
2011       */
2012      public void testAllowCoreThreadTimeOut_false() throws Exception {
2013 <        long coreThreadTimeOut = SHORT_DELAY_MS;
2013 >        long keepAliveTime = timeoutMillis();
2014          final ThreadPoolExecutor p =
2015              new ThreadPoolExecutor(2, 10,
2016 <                                   coreThreadTimeOut, MILLISECONDS,
2016 >                                   keepAliveTime, MILLISECONDS,
2017                                     new ArrayBlockingQueue<Runnable>(10));
2018          final CountDownLatch threadStarted = new CountDownLatch(1);
2019          try {
# Line 1973 | Line 2023 | public class ThreadPoolExecutorTest exte
2023                      threadStarted.countDown();
2024                      assertTrue(p.getPoolSize() >= 1);
2025                  }});
2026 <            delay(2 * coreThreadTimeOut);
2026 >            delay(2 * keepAliveTime);
2027              assertTrue(p.getPoolSize() >= 1);
2028          } finally {
2029              joinPool(p);
# Line 1992 | Line 2042 | public class ThreadPoolExecutorTest exte
2042                  done.countDown();
2043              }};
2044          final ThreadPoolExecutor p =
2045 <            new ThreadPoolExecutor(1, 30, 60, TimeUnit.SECONDS,
2045 >            new ThreadPoolExecutor(1, 30,
2046 >                                   60, SECONDS,
2047                                     new ArrayBlockingQueue(30));
2048          try {
2049              for (int i = 0; i < nTasks; ++i) {
# Line 2011 | Line 2062 | public class ThreadPoolExecutorTest exte
2062          }
2063      }
2064  
2065 +    /**
2066 +     * get(cancelled task) throws CancellationException
2067 +     */
2068 +    public void testGet_cancelled() throws Exception {
2069 +        final ExecutorService e =
2070 +            new ThreadPoolExecutor(1, 1,
2071 +                                   LONG_DELAY_MS, MILLISECONDS,
2072 +                                   new LinkedBlockingQueue<Runnable>());
2073 +        try {
2074 +            final CountDownLatch blockerStarted = new CountDownLatch(1);
2075 +            final CountDownLatch done = new CountDownLatch(1);
2076 +            final List<Future<?>> futures = new ArrayList<>();
2077 +            for (int i = 0; i < 2; i++) {
2078 +                Runnable r = new CheckedRunnable() { public void realRun()
2079 +                                                         throws Throwable {
2080 +                    blockerStarted.countDown();
2081 +                    assertTrue(done.await(2 * LONG_DELAY_MS, MILLISECONDS));
2082 +                }};
2083 +                futures.add(e.submit(r));
2084 +            }
2085 +            assertTrue(blockerStarted.await(LONG_DELAY_MS, MILLISECONDS));
2086 +            for (Future<?> future : futures) future.cancel(false);
2087 +            for (Future<?> future : futures) {
2088 +                try {
2089 +                    future.get();
2090 +                    shouldThrow();
2091 +                } catch (CancellationException success) {}
2092 +                try {
2093 +                    future.get(LONG_DELAY_MS, MILLISECONDS);
2094 +                    shouldThrow();
2095 +                } catch (CancellationException success) {}
2096 +                assertTrue(future.isCancelled());
2097 +                assertTrue(future.isDone());
2098 +            }
2099 +            done.countDown();
2100 +        } finally {
2101 +            joinPool(e);
2102 +        }
2103 +    }
2104 +
2105   }

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines