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.52 by jsr166, Fri May 15 17:07:27 2015 UTC vs.
Revision 1.68 by jsr166, Sun Oct 4 01:27:32 2015 UTC

# Line 15 | Line 15 | 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;
# Line 28 | Line 29 | import java.util.concurrent.SynchronousQ
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;
# Line 130 | Line 132 | public class ThreadPoolExecutorTest exte
132       */
133      public void testPrestartCoreThread() {
134          final ThreadPoolExecutor p =
135 <            new ThreadPoolExecutor(2, 2,
135 >            new ThreadPoolExecutor(2, 6,
136                                     LONG_DELAY_MS, MILLISECONDS,
137                                     new ArrayBlockingQueue<Runnable>(10));
138 <        assertEquals(0, p.getPoolSize());
139 <        assertTrue(p.prestartCoreThread());
140 <        assertEquals(1, p.getPoolSize());
141 <        assertTrue(p.prestartCoreThread());
142 <        assertEquals(2, p.getPoolSize());
143 <        assertFalse(p.prestartCoreThread());
144 <        assertEquals(2, p.getPoolSize());
145 <        joinPool(p);
138 >        try (PoolCleaner cleaner = cleaner(p)) {
139 >            assertEquals(0, p.getPoolSize());
140 >            assertTrue(p.prestartCoreThread());
141 >            assertEquals(1, p.getPoolSize());
142 >            assertTrue(p.prestartCoreThread());
143 >            assertEquals(2, p.getPoolSize());
144 >            assertFalse(p.prestartCoreThread());
145 >            assertEquals(2, p.getPoolSize());
146 >            p.setCorePoolSize(4);
147 >            assertTrue(p.prestartCoreThread());
148 >            assertEquals(3, p.getPoolSize());
149 >            assertTrue(p.prestartCoreThread());
150 >            assertEquals(4, p.getPoolSize());
151 >            assertFalse(p.prestartCoreThread());
152 >            assertEquals(4, p.getPoolSize());
153 >        }
154      }
155  
156      /**
# Line 148 | Line 158 | public class ThreadPoolExecutorTest exte
158       */
159      public void testPrestartAllCoreThreads() {
160          final ThreadPoolExecutor p =
161 <            new ThreadPoolExecutor(2, 2,
161 >            new ThreadPoolExecutor(2, 6,
162                                     LONG_DELAY_MS, MILLISECONDS,
163                                     new ArrayBlockingQueue<Runnable>(10));
164 <        assertEquals(0, p.getPoolSize());
165 <        p.prestartAllCoreThreads();
166 <        assertEquals(2, p.getPoolSize());
167 <        p.prestartAllCoreThreads();
168 <        assertEquals(2, p.getPoolSize());
169 <        joinPool(p);
164 >        try (PoolCleaner cleaner = cleaner(p)) {
165 >            assertEquals(0, p.getPoolSize());
166 >            p.prestartAllCoreThreads();
167 >            assertEquals(2, p.getPoolSize());
168 >            p.prestartAllCoreThreads();
169 >            assertEquals(2, p.getPoolSize());
170 >            p.setCorePoolSize(4);
171 >            p.prestartAllCoreThreads();
172 >            assertEquals(4, p.getPoolSize());
173 >            p.prestartAllCoreThreads();
174 >            assertEquals(4, p.getPoolSize());
175 >        }
176      }
177  
178      /**
# Line 168 | Line 184 | public class ThreadPoolExecutorTest exte
184              new ThreadPoolExecutor(2, 2,
185                                     LONG_DELAY_MS, MILLISECONDS,
186                                     new ArrayBlockingQueue<Runnable>(10));
187 <        final CountDownLatch threadStarted = new CountDownLatch(1);
188 <        final CountDownLatch threadProceed = new CountDownLatch(1);
189 <        final CountDownLatch threadDone = new CountDownLatch(1);
190 <        try {
187 >        try (PoolCleaner cleaner = cleaner(p)) {
188 >            final CountDownLatch threadStarted = new CountDownLatch(1);
189 >            final CountDownLatch threadProceed = new CountDownLatch(1);
190 >            final CountDownLatch threadDone = new CountDownLatch(1);
191              assertEquals(0, p.getCompletedTaskCount());
192              p.execute(new CheckedRunnable() {
193                  public void realRun() throws InterruptedException {
# Line 190 | Line 206 | public class ThreadPoolExecutorTest exte
206                      fail("timed out");
207                  Thread.yield();
208              }
193 –        } finally {
194 –            joinPool(p);
209          }
210      }
211  
# Line 215 | Line 229 | public class ThreadPoolExecutorTest exte
229              new ThreadPoolExecutor(2, 2,
230                                     1000, MILLISECONDS,
231                                     new ArrayBlockingQueue<Runnable>(10));
232 <        assertEquals(1, p.getKeepAliveTime(TimeUnit.SECONDS));
232 >        assertEquals(1, p.getKeepAliveTime(SECONDS));
233          joinPool(p);
234      }
235  
# Line 623 | Line 637 | public class ThreadPoolExecutorTest exte
637      }
638  
639      /**
640 <     * shutdownNow returns a list containing tasks that were not run
640 >     * shutdownNow returns a list containing tasks that were not run,
641 >     * and those tasks are drained from the queue
642       */
643 <    public void testShutdownNow() {
643 >    public void testShutdownNow() throws InterruptedException {
644 >        final int poolSize = 2;
645 >        final int count = 5;
646 >        final AtomicInteger ran = new AtomicInteger(0);
647          final ThreadPoolExecutor p =
648 <            new ThreadPoolExecutor(1, 1,
648 >            new ThreadPoolExecutor(poolSize, poolSize,
649                                     LONG_DELAY_MS, MILLISECONDS,
650                                     new ArrayBlockingQueue<Runnable>(10));
651 <        List l;
652 <        try {
653 <            for (int i = 0; i < 5; i++)
636 <                p.execute(new MediumPossiblyInterruptedRunnable());
637 <        }
638 <        finally {
651 >        CountDownLatch threadsStarted = new CountDownLatch(poolSize);
652 >        Runnable waiter = new CheckedRunnable() { public void realRun() {
653 >            threadsStarted.countDown();
654              try {
655 <                l = p.shutdownNow();
656 <            } catch (SecurityException ok) { return; }
655 >                MILLISECONDS.sleep(2 * LONG_DELAY_MS);
656 >            } catch (InterruptedException success) {}
657 >            ran.getAndIncrement();
658 >        }};
659 >        for (int i = 0; i < count; i++)
660 >            p.execute(waiter);
661 >        assertTrue(threadsStarted.await(LONG_DELAY_MS, MILLISECONDS));
662 >        assertEquals(poolSize, p.getActiveCount());
663 >        assertEquals(0, p.getCompletedTaskCount());
664 >        final List<Runnable> queuedTasks;
665 >        try {
666 >            queuedTasks = p.shutdownNow();
667 >        } catch (SecurityException ok) {
668 >            return; // Allowed in case test doesn't have privs
669          }
670          assertTrue(p.isShutdown());
671 <        assertTrue(l.size() <= 4);
671 >        assertTrue(p.getQueue().isEmpty());
672 >        assertEquals(count - poolSize, queuedTasks.size());
673 >        assertTrue(p.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
674 >        assertTrue(p.isTerminated());
675 >        assertEquals(poolSize, ran.get());
676 >        assertEquals(poolSize, p.getCompletedTaskCount());
677      }
678  
679      // Exception Tests
# Line 990 | Line 1022 | public class ThreadPoolExecutorTest exte
1022      public void testInterruptedSubmit() throws InterruptedException {
1023          final ThreadPoolExecutor p =
1024              new ThreadPoolExecutor(1, 1,
1025 <                                   60, TimeUnit.SECONDS,
1025 >                                   60, SECONDS,
1026                                     new ArrayBlockingQueue<Runnable>(10));
1027  
1028          final CountDownLatch threadStarted = new CountDownLatch(1);
# Line 1264 | Line 1296 | public class ThreadPoolExecutorTest exte
1296       */
1297      public void testExecuteNull() {
1298          ThreadPoolExecutor p =
1299 <            new ThreadPoolExecutor(1, 2,
1268 <                                   LONG_DELAY_MS, MILLISECONDS,
1299 >            new ThreadPoolExecutor(1, 2, 1L, SECONDS,
1300                                     new ArrayBlockingQueue<Runnable>(10));
1301          try {
1302              p.execute(null);
# Line 1332 | Line 1363 | public class ThreadPoolExecutorTest exte
1363      }
1364  
1365      /**
1366 +     * Configuration changes that allow core pool size greater than
1367 +     * max pool size result in IllegalArgumentException.
1368 +     */
1369 +    public void testPoolSizeInvariants() {
1370 +        ThreadPoolExecutor p =
1371 +            new ThreadPoolExecutor(1, 1,
1372 +                                   LONG_DELAY_MS, MILLISECONDS,
1373 +                                   new ArrayBlockingQueue<Runnable>(10));
1374 +        for (int s = 1; s < 5; s++) {
1375 +            p.setMaximumPoolSize(s);
1376 +            p.setCorePoolSize(s);
1377 +            try {
1378 +                p.setMaximumPoolSize(s - 1);
1379 +                shouldThrow();
1380 +            } catch (IllegalArgumentException success) {}
1381 +            assertEquals(s, p.getCorePoolSize());
1382 +            assertEquals(s, p.getMaximumPoolSize());
1383 +            try {
1384 +                p.setCorePoolSize(s + 1);
1385 +                shouldThrow();
1386 +            } catch (IllegalArgumentException success) {}
1387 +            assertEquals(s, p.getCorePoolSize());
1388 +            assertEquals(s, p.getMaximumPoolSize());
1389 +        }
1390 +        joinPool(p);
1391 +    }
1392 +
1393 +    /**
1394       * setKeepAliveTime throws IllegalArgumentException
1395       * when given a negative value
1396       */
# Line 1847 | Line 1906 | public class ThreadPoolExecutorTest exte
1906              l.add(new StringTask());
1907              l.add(new StringTask());
1908              List<Future<String>> futures =
1909 <                e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
1909 >                e.invokeAll(l, LONG_DELAY_MS, MILLISECONDS);
1910              assertEquals(2, futures.size());
1911              for (Future<String> future : futures)
1912                  assertSame(TEST_STRING, future.get());
# Line 1865 | Line 1924 | public class ThreadPoolExecutorTest exte
1924                                     LONG_DELAY_MS, MILLISECONDS,
1925                                     new ArrayBlockingQueue<Runnable>(10));
1926          try {
1927 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
1928 <            l.add(new StringTask());
1929 <            l.add(Executors.callable(new MediumPossiblyInterruptedRunnable(), TEST_STRING));
1930 <            l.add(new StringTask());
1931 <            List<Future<String>> futures =
1932 <                e.invokeAll(l, SHORT_DELAY_MS, MILLISECONDS);
1933 <            assertEquals(l.size(), futures.size());
1934 <            for (Future future : futures)
1935 <                assertTrue(future.isDone());
1936 <            assertFalse(futures.get(0).isCancelled());
1937 <            assertTrue(futures.get(1).isCancelled());
1927 >            for (long timeout = timeoutMillis();;) {
1928 >                List<Callable<String>> tasks = new ArrayList<>();
1929 >                tasks.add(new StringTask("0"));
1930 >                tasks.add(Executors.callable(new LongPossiblyInterruptedRunnable(), TEST_STRING));
1931 >                tasks.add(new StringTask("2"));
1932 >                long startTime = System.nanoTime();
1933 >                List<Future<String>> futures =
1934 >                    e.invokeAll(tasks, timeout, MILLISECONDS);
1935 >                assertEquals(tasks.size(), futures.size());
1936 >                assertTrue(millisElapsedSince(startTime) >= timeout);
1937 >                for (Future future : futures)
1938 >                    assertTrue(future.isDone());
1939 >                assertTrue(futures.get(1).isCancelled());
1940 >                try {
1941 >                    assertEquals("0", futures.get(0).get());
1942 >                    assertEquals("2", futures.get(2).get());
1943 >                    break;
1944 >                } catch (CancellationException retryWithLongerTimeout) {
1945 >                    timeout *= 2;
1946 >                    if (timeout >= LONG_DELAY_MS / 2)
1947 >                        fail("expected exactly one task to be cancelled");
1948 >                }
1949 >            }
1950          } finally {
1951              joinPool(e);
1952          }
# Line 1921 | Line 1992 | public class ThreadPoolExecutorTest exte
1992       * allowCoreThreadTimeOut(true) causes idle threads to time out
1993       */
1994      public void testAllowCoreThreadTimeOut_true() throws Exception {
1995 <        long coreThreadTimeOut = SHORT_DELAY_MS;
1995 >        long keepAliveTime = timeoutMillis();
1996          final ThreadPoolExecutor p =
1997              new ThreadPoolExecutor(2, 10,
1998 <                                   coreThreadTimeOut, MILLISECONDS,
1998 >                                   keepAliveTime, MILLISECONDS,
1999                                     new ArrayBlockingQueue<Runnable>(10));
2000          final CountDownLatch threadStarted = new CountDownLatch(1);
2001          try {
# Line 1935 | Line 2006 | public class ThreadPoolExecutorTest exte
2006                      assertEquals(1, p.getPoolSize());
2007                  }});
2008              await(threadStarted);
2009 <            delay(coreThreadTimeOut);
2009 >            delay(keepAliveTime);
2010              long startTime = System.nanoTime();
2011              while (p.getPoolSize() > 0
2012                     && millisElapsedSince(startTime) < LONG_DELAY_MS)
# Line 1951 | Line 2022 | public class ThreadPoolExecutorTest exte
2022       * allowCoreThreadTimeOut(false) causes idle threads not to time out
2023       */
2024      public void testAllowCoreThreadTimeOut_false() throws Exception {
2025 <        long coreThreadTimeOut = SHORT_DELAY_MS;
2025 >        long keepAliveTime = timeoutMillis();
2026          final ThreadPoolExecutor p =
2027              new ThreadPoolExecutor(2, 10,
2028 <                                   coreThreadTimeOut, MILLISECONDS,
2028 >                                   keepAliveTime, MILLISECONDS,
2029                                     new ArrayBlockingQueue<Runnable>(10));
2030          final CountDownLatch threadStarted = new CountDownLatch(1);
2031          try {
# Line 1964 | Line 2035 | public class ThreadPoolExecutorTest exte
2035                      threadStarted.countDown();
2036                      assertTrue(p.getPoolSize() >= 1);
2037                  }});
2038 <            delay(2 * coreThreadTimeOut);
2038 >            delay(2 * keepAliveTime);
2039              assertTrue(p.getPoolSize() >= 1);
2040          } finally {
2041              joinPool(p);
# Line 1983 | Line 2054 | public class ThreadPoolExecutorTest exte
2054                  done.countDown();
2055              }};
2056          final ThreadPoolExecutor p =
2057 <            new ThreadPoolExecutor(1, 30, 60, TimeUnit.SECONDS,
2057 >            new ThreadPoolExecutor(1, 30,
2058 >                                   60, SECONDS,
2059                                     new ArrayBlockingQueue(30));
2060          try {
2061              for (int i = 0; i < nTasks; ++i) {
# Line 2002 | Line 2074 | public class ThreadPoolExecutorTest exte
2074          }
2075      }
2076  
2077 +    /**
2078 +     * get(cancelled task) throws CancellationException
2079 +     */
2080 +    public void testGet_cancelled() throws Exception {
2081 +        final ExecutorService e =
2082 +            new ThreadPoolExecutor(1, 1,
2083 +                                   LONG_DELAY_MS, MILLISECONDS,
2084 +                                   new LinkedBlockingQueue<Runnable>());
2085 +        try {
2086 +            final CountDownLatch blockerStarted = new CountDownLatch(1);
2087 +            final CountDownLatch done = new CountDownLatch(1);
2088 +            final List<Future<?>> futures = new ArrayList<>();
2089 +            for (int i = 0; i < 2; i++) {
2090 +                Runnable r = new CheckedRunnable() { public void realRun()
2091 +                                                         throws Throwable {
2092 +                    blockerStarted.countDown();
2093 +                    assertTrue(done.await(2 * LONG_DELAY_MS, MILLISECONDS));
2094 +                }};
2095 +                futures.add(e.submit(r));
2096 +            }
2097 +            assertTrue(blockerStarted.await(LONG_DELAY_MS, MILLISECONDS));
2098 +            for (Future<?> future : futures) future.cancel(false);
2099 +            for (Future<?> future : futures) {
2100 +                try {
2101 +                    future.get();
2102 +                    shouldThrow();
2103 +                } catch (CancellationException success) {}
2104 +                try {
2105 +                    future.get(LONG_DELAY_MS, MILLISECONDS);
2106 +                    shouldThrow();
2107 +                } catch (CancellationException success) {}
2108 +                assertTrue(future.isCancelled());
2109 +                assertTrue(future.isDone());
2110 +            }
2111 +            done.countDown();
2112 +        } finally {
2113 +            joinPool(e);
2114 +        }
2115 +    }
2116 +
2117   }

Diff Legend

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