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.81 by jsr166, Sun Oct 4 02:24:49 2015 UTC vs.
Revision 1.95 by jsr166, Sun Oct 4 03:58:22 2015 UTC

# Line 426 | Line 426 | public class ThreadPoolExecutorTest exte
426              new ThreadPoolExecutor(1, 1,
427                                     LONG_DELAY_MS, MILLISECONDS,
428                                     new ArrayBlockingQueue<Runnable>(10));
429 <        assertFalse(p.isShutdown());
430 <        try { p.shutdown(); } catch (SecurityException ok) { return; }
431 <        assertTrue(p.isShutdown());
432 <        joinPool(p);
429 >        try (PoolCleaner cleaner = cleaner(p)) {
430 >            assertFalse(p.isShutdown());
431 >            try { p.shutdown(); } catch (SecurityException ok) { return; }
432 >            assertTrue(p.isShutdown());
433 >        }
434      }
435  
436      /**
# Line 440 | Line 441 | public class ThreadPoolExecutorTest exte
441              new ThreadPoolExecutor(1, 1,
442                                     LONG_DELAY_MS, MILLISECONDS,
443                                     new ArrayBlockingQueue<Runnable>(10));
444 <        assertFalse(p.isTerminated());
445 <        assertFalse(p.awaitTermination(Long.MIN_VALUE, NANOSECONDS));
446 <        assertFalse(p.awaitTermination(Long.MIN_VALUE, MILLISECONDS));
447 <        assertFalse(p.awaitTermination(-1L, NANOSECONDS));
448 <        assertFalse(p.awaitTermination(-1L, MILLISECONDS));
449 <        assertFalse(p.awaitTermination(0L, NANOSECONDS));
450 <        assertFalse(p.awaitTermination(0L, MILLISECONDS));
451 <        long timeoutNanos = 999999L;
452 <        long startTime = System.nanoTime();
453 <        assertFalse(p.awaitTermination(timeoutNanos, NANOSECONDS));
454 <        assertTrue(System.nanoTime() - startTime >= timeoutNanos);
455 <        assertFalse(p.isTerminated());
456 <        startTime = System.nanoTime();
457 <        long timeoutMillis = timeoutMillis();
458 <        assertFalse(p.awaitTermination(timeoutMillis, MILLISECONDS));
459 <        assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
460 <        assertFalse(p.isTerminated());
461 <        p.shutdown();
462 <        assertTrue(p.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
463 <        assertTrue(p.isTerminated());
444 >        try (PoolCleaner cleaner = cleaner(p)) {
445 >            assertFalse(p.isTerminated());
446 >            assertFalse(p.awaitTermination(Long.MIN_VALUE, NANOSECONDS));
447 >            assertFalse(p.awaitTermination(Long.MIN_VALUE, MILLISECONDS));
448 >            assertFalse(p.awaitTermination(-1L, NANOSECONDS));
449 >            assertFalse(p.awaitTermination(-1L, MILLISECONDS));
450 >            assertFalse(p.awaitTermination(0L, NANOSECONDS));
451 >            assertFalse(p.awaitTermination(0L, MILLISECONDS));
452 >            long timeoutNanos = 999999L;
453 >            long startTime = System.nanoTime();
454 >            assertFalse(p.awaitTermination(timeoutNanos, NANOSECONDS));
455 >            assertTrue(System.nanoTime() - startTime >= timeoutNanos);
456 >            assertFalse(p.isTerminated());
457 >            startTime = System.nanoTime();
458 >            long timeoutMillis = timeoutMillis();
459 >            assertFalse(p.awaitTermination(timeoutMillis, MILLISECONDS));
460 >            assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
461 >            assertFalse(p.isTerminated());
462 >            try { p.shutdown(); } catch (SecurityException ok) { return; }
463 >            assertTrue(p.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
464 >            assertTrue(p.isTerminated());
465 >        }
466      }
467  
468      /**
# Line 470 | Line 473 | public class ThreadPoolExecutorTest exte
473              new ThreadPoolExecutor(1, 1,
474                                     LONG_DELAY_MS, MILLISECONDS,
475                                     new ArrayBlockingQueue<Runnable>(10));
476 <        final CountDownLatch threadStarted = new CountDownLatch(1);
477 <        final CountDownLatch done = new CountDownLatch(1);
478 <        assertFalse(p.isTerminated());
479 <        try {
476 >        try (PoolCleaner cleaner = cleaner(p)) {
477 >            final CountDownLatch threadStarted = new CountDownLatch(1);
478 >            final CountDownLatch done = new CountDownLatch(1);
479 >            assertFalse(p.isTerminating());
480              p.execute(new CheckedRunnable() {
481                  public void realRun() throws InterruptedException {
482 <                    assertFalse(p.isTerminated());
482 >                    assertFalse(p.isTerminating());
483                      threadStarted.countDown();
484                      done.await();
485                  }});
486              assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
487              assertFalse(p.isTerminating());
488              done.countDown();
486 –        } finally {
489              try { p.shutdown(); } catch (SecurityException ok) { return; }
490 +            assertTrue(p.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
491 +            assertTrue(p.isTerminated());
492 +            assertFalse(p.isTerminating());
493          }
489 –        assertTrue(p.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
490 –        assertTrue(p.isTerminated());
494      }
495  
496      /**
# Line 498 | Line 501 | public class ThreadPoolExecutorTest exte
501              new ThreadPoolExecutor(1, 1,
502                                     LONG_DELAY_MS, MILLISECONDS,
503                                     new ArrayBlockingQueue<Runnable>(10));
504 <        final CountDownLatch threadStarted = new CountDownLatch(1);
505 <        final CountDownLatch done = new CountDownLatch(1);
506 <        try {
504 >        try (PoolCleaner cleaner = cleaner(p)) {
505 >            final CountDownLatch threadStarted = new CountDownLatch(1);
506 >            final CountDownLatch done = new CountDownLatch(1);
507              assertFalse(p.isTerminating());
508              p.execute(new CheckedRunnable() {
509                  public void realRun() throws InterruptedException {
# Line 511 | Line 514 | public class ThreadPoolExecutorTest exte
514              assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
515              assertFalse(p.isTerminating());
516              done.countDown();
514 –        } finally {
517              try { p.shutdown(); } catch (SecurityException ok) { return; }
518 +            assertTrue(p.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
519 +            assertTrue(p.isTerminated());
520 +            assertFalse(p.isTerminating());
521          }
517 –        assertTrue(p.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
518 –        assertTrue(p.isTerminated());
519 –        assertFalse(p.isTerminating());
522      }
523  
524      /**
# Line 528 | Line 530 | public class ThreadPoolExecutorTest exte
530              new ThreadPoolExecutor(1, 1,
531                                     LONG_DELAY_MS, MILLISECONDS,
532                                     q);
533 <        final CountDownLatch threadStarted = new CountDownLatch(1);
534 <        final CountDownLatch done = new CountDownLatch(1);
535 <        try {
533 >        try (PoolCleaner cleaner = cleaner(p)) {
534 >            final CountDownLatch threadStarted = new CountDownLatch(1);
535 >            final CountDownLatch done = new CountDownLatch(1);
536              FutureTask[] tasks = new FutureTask[5];
537              for (int i = 0; i < tasks.length; i++) {
538                  Callable task = new CheckedCallable<Boolean>() {
# Line 548 | Line 550 | public class ThreadPoolExecutorTest exte
550              assertFalse(q.contains(tasks[0]));
551              assertTrue(q.contains(tasks[tasks.length - 1]));
552              assertEquals(tasks.length - 1, q.size());
551 –        } finally {
553              done.countDown();
553 –            joinPool(p);
554          }
555      }
556  
# Line 563 | Line 563 | public class ThreadPoolExecutorTest exte
563              new ThreadPoolExecutor(1, 1,
564                                     LONG_DELAY_MS, MILLISECONDS,
565                                     q);
566 <        Runnable[] tasks = new Runnable[5];
567 <        final CountDownLatch threadStarted = new CountDownLatch(1);
568 <        final CountDownLatch done = new CountDownLatch(1);
569 <        try {
566 >        try (PoolCleaner cleaner = cleaner(p)) {
567 >            Runnable[] tasks = new Runnable[6];
568 >            final CountDownLatch threadStarted = new CountDownLatch(1);
569 >            final CountDownLatch done = new CountDownLatch(1);
570              for (int i = 0; i < tasks.length; i++) {
571                  tasks[i] = new CheckedRunnable() {
572                      public void realRun() throws InterruptedException {
# Line 585 | Line 585 | public class ThreadPoolExecutorTest exte
585              assertTrue(q.contains(tasks[3]));
586              assertTrue(p.remove(tasks[3]));
587              assertFalse(q.contains(tasks[3]));
588 –        } finally {
588              done.countDown();
590 –            joinPool(p);
589          }
590      }
591  
# Line 602 | Line 600 | public class ThreadPoolExecutorTest exte
600              new ThreadPoolExecutor(1, 1,
601                                     LONG_DELAY_MS, MILLISECONDS,
602                                     q);
603 <        FutureTask[] tasks = new FutureTask[5];
604 <        try {
603 >        try (PoolCleaner cleaner = cleaner(p)) {
604 >            FutureTask[] tasks = new FutureTask[5];
605              for (int i = 0; i < tasks.length; i++) {
606                  Callable task = new CheckedCallable<Boolean>() {
607                      public Boolean realCall() throws InterruptedException {
# Line 627 | Line 625 | public class ThreadPoolExecutorTest exte
625              p.purge();         // Nothing to do
626              assertEquals(tasks.length - 3, q.size());
627              assertEquals(tasks.length - 2, p.getTaskCount());
630 –        } finally {
628              done.countDown();
632 –            joinPool(p);
629          }
630      }
631  
# Line 1022 | Line 1018 | public class ThreadPoolExecutorTest exte
1018                                     60, SECONDS,
1019                                     new ArrayBlockingQueue<Runnable>(10));
1020  
1021 <        final CountDownLatch threadStarted = new CountDownLatch(1);
1022 <        final CountDownLatch done = new CountDownLatch(1);
1023 <        try {
1021 >        try (PoolCleaner cleaner = cleaner(p)) {
1022 >            final CountDownLatch threadStarted = new CountDownLatch(1);
1023 >            final CountDownLatch done = new CountDownLatch(1);
1024              Thread t = newStartedThread(new CheckedInterruptedRunnable() {
1025                  public void realRun() throws Exception {
1026                      Callable task = new CheckedCallable<Boolean>() {
# Line 1039 | Line 1035 | public class ThreadPoolExecutorTest exte
1035              assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
1036              t.interrupt();
1037              awaitTermination(t, MEDIUM_DELAY_MS);
1042 –        } finally {
1038              done.countDown();
1044 –            joinPool(p);
1039          }
1040      }
1041  
# Line 1049 | Line 1043 | public class ThreadPoolExecutorTest exte
1043       * execute throws RejectedExecutionException if saturated.
1044       */
1045      public void testSaturatedExecute() {
1046 <        ThreadPoolExecutor p =
1046 >        final ThreadPoolExecutor p =
1047              new ThreadPoolExecutor(1, 1,
1048                                     LONG_DELAY_MS, MILLISECONDS,
1049                                     new ArrayBlockingQueue<Runnable>(1));
1050 <        final CountDownLatch done = new CountDownLatch(1);
1051 <        try {
1050 >        try (PoolCleaner cleaner = cleaner(p)) {
1051 >            final CountDownLatch done = new CountDownLatch(1);
1052              Runnable task = new CheckedRunnable() {
1053                  public void realRun() throws InterruptedException {
1054                      done.await();
# Line 1068 | Line 1062 | public class ThreadPoolExecutorTest exte
1062                  } catch (RejectedExecutionException success) {}
1063                  assertTrue(p.getTaskCount() <= 2);
1064              }
1071 –        } finally {
1065              done.countDown();
1073 –            joinPool(p);
1066          }
1067      }
1068  
# Line 1136 | Line 1128 | public class ThreadPoolExecutorTest exte
1128       * executor using CallerRunsPolicy runs task if saturated.
1129       */
1130      public void testSaturatedExecute2() {
1139 –        RejectedExecutionHandler h = new ThreadPoolExecutor.CallerRunsPolicy();
1131          final ThreadPoolExecutor p =
1132              new ThreadPoolExecutor(1, 1,
1133                                     LONG_DELAY_MS,
1134                                     MILLISECONDS,
1135                                     new ArrayBlockingQueue<Runnable>(1),
1136 <                                   h);
1137 <        try {
1136 >                                   new ThreadPoolExecutor.CallerRunsPolicy());
1137 >        try (PoolCleaner cleaner = cleaner(p)) {
1138 >            final CountDownLatch done = new CountDownLatch(1);
1139 >            Runnable blocker = new CheckedRunnable() {
1140 >                public void realRun() throws InterruptedException {
1141 >                    done.await();
1142 >                }};
1143 >            p.execute(blocker);
1144              TrackedNoOpRunnable[] tasks = new TrackedNoOpRunnable[5];
1145 <            for (int i = 0; i < tasks.length; ++i)
1145 >            for (int i = 0; i < tasks.length; i++)
1146                  tasks[i] = new TrackedNoOpRunnable();
1147 <            TrackedLongRunnable mr = new TrackedLongRunnable();
1151 <            p.execute(mr);
1152 <            for (int i = 0; i < tasks.length; ++i)
1147 >            for (int i = 0; i < tasks.length; i++)
1148                  p.execute(tasks[i]);
1149 <            for (int i = 1; i < tasks.length; ++i)
1149 >            for (int i = 1; i < tasks.length; i++)
1150                  assertTrue(tasks[i].done);
1151 <            try { p.shutdownNow(); } catch (SecurityException ok) { return; }
1152 <        } finally {
1158 <            joinPool(p);
1151 >            assertFalse(tasks[0].done); // waiting in queue
1152 >            done.countDown();
1153          }
1154      }
1155  
# Line 1163 | Line 1157 | public class ThreadPoolExecutorTest exte
1157       * executor using DiscardPolicy drops task if saturated.
1158       */
1159      public void testSaturatedExecute3() {
1160 <        RejectedExecutionHandler h = new ThreadPoolExecutor.DiscardPolicy();
1160 >        final TrackedNoOpRunnable[] tasks = new TrackedNoOpRunnable[5];
1161 >        for (int i = 0; i < tasks.length; ++i)
1162 >            tasks[i] = new TrackedNoOpRunnable();
1163          final ThreadPoolExecutor p =
1164              new ThreadPoolExecutor(1, 1,
1165 <                                   LONG_DELAY_MS, MILLISECONDS,
1166 <                                   new ArrayBlockingQueue<Runnable>(1),
1167 <                                   h);
1168 <        try {
1169 <            TrackedNoOpRunnable[] tasks = new TrackedNoOpRunnable[5];
1170 <            for (int i = 0; i < tasks.length; ++i)
1171 <                tasks[i] = new TrackedNoOpRunnable();
1176 <            p.execute(new TrackedLongRunnable());
1165 >                          LONG_DELAY_MS, MILLISECONDS,
1166 >                          new ArrayBlockingQueue<Runnable>(1),
1167 >                          new ThreadPoolExecutor.DiscardPolicy());
1168 >        try (PoolCleaner cleaner = cleaner(p)) {
1169 >            final CountDownLatch done = new CountDownLatch(1);
1170 >            p.execute(awaiter(done));
1171 >
1172              for (TrackedNoOpRunnable task : tasks)
1173                  p.execute(task);
1174 <            for (TrackedNoOpRunnable task : tasks)
1175 <                assertFalse(task.done);
1176 <            try { p.shutdownNow(); } catch (SecurityException ok) { return; }
1182 <        } finally {
1183 <            joinPool(p);
1174 >            for (int i = 1; i < tasks.length; i++)
1175 >                assertFalse(tasks[i].done);
1176 >            done.countDown();
1177          }
1178 +        for (int i = 1; i < tasks.length; i++)
1179 +            assertFalse(tasks[i].done);
1180 +        assertTrue(tasks[0].done); // was waiting in queue
1181      }
1182  
1183      /**
1184       * executor using DiscardOldestPolicy drops oldest task if saturated.
1185       */
1186      public void testSaturatedExecute4() {
1187 <        RejectedExecutionHandler h = new ThreadPoolExecutor.DiscardOldestPolicy();
1187 >        final CountDownLatch done = new CountDownLatch(1);
1188 >        LatchAwaiter r1 = awaiter(done);
1189 >        LatchAwaiter r2 = awaiter(done);
1190 >        LatchAwaiter r3 = awaiter(done);
1191          final ThreadPoolExecutor p =
1192              new ThreadPoolExecutor(1, 1,
1193                                     LONG_DELAY_MS, MILLISECONDS,
1194                                     new ArrayBlockingQueue<Runnable>(1),
1195 <                                   h);
1196 <        try {
1197 <            p.execute(new TrackedLongRunnable());
1198 <            TrackedLongRunnable r2 = new TrackedLongRunnable();
1195 >                                   new ThreadPoolExecutor.DiscardOldestPolicy());
1196 >        try (PoolCleaner cleaner = cleaner(p)) {
1197 >            assertEquals(LatchAwaiter.NEW, r1.state);
1198 >            assertEquals(LatchAwaiter.NEW, r2.state);
1199 >            assertEquals(LatchAwaiter.NEW, r3.state);
1200 >            p.execute(r1);
1201              p.execute(r2);
1202              assertTrue(p.getQueue().contains(r2));
1202 –            TrackedNoOpRunnable r3 = new TrackedNoOpRunnable();
1203              p.execute(r3);
1204              assertFalse(p.getQueue().contains(r2));
1205              assertTrue(p.getQueue().contains(r3));
1206 <            try { p.shutdownNow(); } catch (SecurityException ok) { return; }
1207 <        } finally {
1208 <            joinPool(p);
1206 >            done.countDown();
1207          }
1208 +        assertEquals(LatchAwaiter.DONE, r1.state);
1209 +        assertEquals(LatchAwaiter.NEW, r2.state);
1210 +        assertEquals(LatchAwaiter.DONE, r3.state);
1211      }
1212  
1213      /**
# Line 1218 | Line 1219 | public class ThreadPoolExecutorTest exte
1219                                     LONG_DELAY_MS, MILLISECONDS,
1220                                     new ArrayBlockingQueue<Runnable>(1));
1221          try { p.shutdown(); } catch (SecurityException ok) { return; }
1222 <        try {
1223 <            p.execute(new NoOpRunnable());
1224 <            shouldThrow();
1225 <        } catch (RejectedExecutionException success) {}
1226 <
1227 <        joinPool(p);
1222 >        try (PoolCleaner cleaner = cleaner(p)) {
1223 >            try {
1224 >                p.execute(new NoOpRunnable());
1225 >                shouldThrow();
1226 >            } catch (RejectedExecutionException success) {}
1227 >        }
1228      }
1229  
1230      /**
# Line 1237 | Line 1238 | public class ThreadPoolExecutorTest exte
1238                                     new ArrayBlockingQueue<Runnable>(1), h);
1239  
1240          try { p.shutdown(); } catch (SecurityException ok) { return; }
1241 <        try {
1241 >        try (PoolCleaner cleaner = cleaner(p)) {
1242              TrackedNoOpRunnable r = new TrackedNoOpRunnable();
1243              p.execute(r);
1244              assertFalse(r.done);
1244 –        } finally {
1245 –            joinPool(p);
1245          }
1246      }
1247  
# Line 1250 | Line 1249 | public class ThreadPoolExecutorTest exte
1249       * execute using DiscardPolicy drops task on shutdown
1250       */
1251      public void testDiscardOnShutdown() {
1252 <        RejectedExecutionHandler h = new ThreadPoolExecutor.DiscardPolicy();
1254 <        ThreadPoolExecutor p =
1252 >        final ThreadPoolExecutor p =
1253              new ThreadPoolExecutor(1, 1,
1254                                     LONG_DELAY_MS, MILLISECONDS,
1255                                     new ArrayBlockingQueue<Runnable>(1),
1256 <                                   h);
1256 >                                   new ThreadPoolExecutor.DiscardPolicy());
1257  
1258          try { p.shutdown(); } catch (SecurityException ok) { return; }
1259 <        try {
1259 >        try (PoolCleaner cleaner = cleaner(p)) {
1260              TrackedNoOpRunnable r = new TrackedNoOpRunnable();
1261              p.execute(r);
1262              assertFalse(r.done);
1265 –        } finally {
1266 –            joinPool(p);
1263          }
1264      }
1265  
# Line 1271 | Line 1267 | public class ThreadPoolExecutorTest exte
1267       * execute using DiscardOldestPolicy drops task on shutdown
1268       */
1269      public void testDiscardOldestOnShutdown() {
1270 <        RejectedExecutionHandler h = new ThreadPoolExecutor.DiscardOldestPolicy();
1275 <        ThreadPoolExecutor p =
1270 >        final ThreadPoolExecutor p =
1271              new ThreadPoolExecutor(1, 1,
1272                                     LONG_DELAY_MS, MILLISECONDS,
1273                                     new ArrayBlockingQueue<Runnable>(1),
1274 <                                   h);
1274 >                                   new ThreadPoolExecutor.DiscardOldestPolicy());
1275  
1276          try { p.shutdown(); } catch (SecurityException ok) { return; }
1277 <        try {
1277 >        try (PoolCleaner cleaner = cleaner(p)) {
1278              TrackedNoOpRunnable r = new TrackedNoOpRunnable();
1279              p.execute(r);
1280              assertFalse(r.done);
1286 –        } finally {
1287 –            joinPool(p);
1281          }
1282      }
1283  
# Line 1292 | Line 1285 | public class ThreadPoolExecutorTest exte
1285       * execute(null) throws NPE
1286       */
1287      public void testExecuteNull() {
1288 <        ThreadPoolExecutor p =
1289 <            new ThreadPoolExecutor(1, 2, 1L, SECONDS,
1288 >        final ThreadPoolExecutor p =
1289 >            new ThreadPoolExecutor(1, 2,
1290 >                                   1L, SECONDS,
1291                                     new ArrayBlockingQueue<Runnable>(10));
1292 <        try {
1293 <            p.execute(null);
1294 <            shouldThrow();
1295 <        } catch (NullPointerException success) {}
1296 <
1297 <        joinPool(p);
1292 >        try (PoolCleaner cleaner = cleaner(p)) {
1293 >            try {
1294 >                p.execute(null);
1295 >                shouldThrow();
1296 >            } catch (NullPointerException success) {}
1297 >        }
1298      }
1299  
1300      /**

Diff Legend

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