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.108 by jsr166, Tue Oct 6 05:30:44 2015 UTC vs.
Revision 1.110 by jsr166, Tue Oct 6 16:39:06 2015 UTC

# Line 101 | Line 101 | public class ThreadPoolExecutorTest exte
101       * thread becomes active
102       */
103      public void testGetActiveCount() throws InterruptedException {
104 +        final CountDownLatch done = new CountDownLatch(1);
105          final ThreadPoolExecutor p =
106              new ThreadPoolExecutor(2, 2,
107                                     LONG_DELAY_MS, MILLISECONDS,
108                                     new ArrayBlockingQueue<Runnable>(10));
109 <        try (PoolCleaner cleaner = cleaner(p)) {
109 >        try (PoolCleaner cleaner = cleaner(p, done)) {
110              final CountDownLatch threadStarted = new CountDownLatch(1);
110 –            final CountDownLatch done = new CountDownLatch(1);
111              assertEquals(0, p.getActiveCount());
112              p.execute(new CheckedRunnable() {
113                  public void realRun() throws InterruptedException {
# Line 117 | Line 117 | public class ThreadPoolExecutorTest exte
117                  }});
118              await(threadStarted);
119              assertEquals(1, p.getActiveCount());
120 –            done.countDown();
120          }
121      }
122  
# Line 537 | Line 536 | public class ThreadPoolExecutorTest exte
536       * getQueue returns the work queue, which contains queued tasks
537       */
538      public void testGetQueue() throws InterruptedException {
539 +        final CountDownLatch done = new CountDownLatch(1);
540          final BlockingQueue<Runnable> q = new ArrayBlockingQueue<Runnable>(10);
541          final ThreadPoolExecutor p =
542              new ThreadPoolExecutor(1, 1,
543                                     LONG_DELAY_MS, MILLISECONDS,
544                                     q);
545 <        try (PoolCleaner cleaner = cleaner(p)) {
545 >        try (PoolCleaner cleaner = cleaner(p, done)) {
546              final CountDownLatch threadStarted = new CountDownLatch(1);
547 –            final CountDownLatch done = new CountDownLatch(1);
547              FutureTask[] tasks = new FutureTask[5];
548              for (int i = 0; i < tasks.length; i++) {
549                  Callable task = new CheckedCallable<Boolean>() {
# Line 562 | Line 561 | public class ThreadPoolExecutorTest exte
561              assertFalse(q.contains(tasks[0]));
562              assertTrue(q.contains(tasks[tasks.length - 1]));
563              assertEquals(tasks.length - 1, q.size());
565 –            done.countDown();
564          }
565      }
566  
# Line 570 | Line 568 | public class ThreadPoolExecutorTest exte
568       * remove(task) removes queued task, and fails to remove active task
569       */
570      public void testRemove() throws InterruptedException {
571 +        final CountDownLatch done = new CountDownLatch(1);
572          BlockingQueue<Runnable> q = new ArrayBlockingQueue<Runnable>(10);
573          final ThreadPoolExecutor p =
574              new ThreadPoolExecutor(1, 1,
575                                     LONG_DELAY_MS, MILLISECONDS,
576                                     q);
577 <        try (PoolCleaner cleaner = cleaner(p)) {
577 >        try (PoolCleaner cleaner = cleaner(p, done)) {
578              Runnable[] tasks = new Runnable[6];
579              final CountDownLatch threadStarted = new CountDownLatch(1);
581 –            final CountDownLatch done = new CountDownLatch(1);
580              for (int i = 0; i < tasks.length; i++) {
581                  tasks[i] = new CheckedRunnable() {
582                      public void realRun() throws InterruptedException {
# Line 597 | Line 595 | public class ThreadPoolExecutorTest exte
595              assertTrue(q.contains(tasks[3]));
596              assertTrue(p.remove(tasks[3]));
597              assertFalse(q.contains(tasks[3]));
600 –            done.countDown();
598          }
599      }
600  
# Line 1053 | Line 1050 | public class ThreadPoolExecutorTest exte
1050       * execute throws RejectedExecutionException if saturated.
1051       */
1052      public void testSaturatedExecute() {
1053 +        final CountDownLatch done = new CountDownLatch(1);
1054          final ThreadPoolExecutor p =
1055              new ThreadPoolExecutor(1, 1,
1056                                     LONG_DELAY_MS, MILLISECONDS,
1057                                     new ArrayBlockingQueue<Runnable>(1));
1058 <        try (PoolCleaner cleaner = cleaner(p)) {
1061 <            final CountDownLatch done = new CountDownLatch(1);
1058 >        try (PoolCleaner cleaner = cleaner(p, done)) {
1059              Runnable task = new CheckedRunnable() {
1060                  public void realRun() throws InterruptedException {
1061                      await(done);
# Line 1072 | Line 1069 | public class ThreadPoolExecutorTest exte
1069                  } catch (RejectedExecutionException success) {}
1070                  assertTrue(p.getTaskCount() <= 2);
1071              }
1075 –            done.countDown();
1072          }
1073      }
1074  
# Line 1080 | Line 1076 | public class ThreadPoolExecutorTest exte
1076       * submit(runnable) throws RejectedExecutionException if saturated.
1077       */
1078      public void testSaturatedSubmitRunnable() {
1079 +        final CountDownLatch done = new CountDownLatch(1);
1080          final ThreadPoolExecutor p =
1081              new ThreadPoolExecutor(1, 1,
1082                                     LONG_DELAY_MS, MILLISECONDS,
1083                                     new ArrayBlockingQueue<Runnable>(1));
1084 <        try (PoolCleaner cleaner = cleaner(p)) {
1088 <            final CountDownLatch done = new CountDownLatch(1);
1084 >        try (PoolCleaner cleaner = cleaner(p, done)) {
1085              Runnable task = new CheckedRunnable() {
1086                  public void realRun() throws InterruptedException {
1087                      await(done);
# Line 1099 | Line 1095 | public class ThreadPoolExecutorTest exte
1095                  } catch (RejectedExecutionException success) {}
1096                  assertTrue(p.getTaskCount() <= 2);
1097              }
1102 –            done.countDown();
1098          }
1099      }
1100  
# Line 1107 | Line 1102 | public class ThreadPoolExecutorTest exte
1102       * submit(callable) throws RejectedExecutionException if saturated.
1103       */
1104      public void testSaturatedSubmitCallable() {
1105 +        final CountDownLatch done = new CountDownLatch(1);
1106          final ThreadPoolExecutor p =
1107              new ThreadPoolExecutor(1, 1,
1108                                     LONG_DELAY_MS, MILLISECONDS,
1109                                     new ArrayBlockingQueue<Runnable>(1));
1110 <        try (PoolCleaner cleaner = cleaner(p)) {
1115 <            final CountDownLatch done = new CountDownLatch(1);
1110 >        try (PoolCleaner cleaner = cleaner(p, done)) {
1111              Runnable task = new CheckedRunnable() {
1112                  public void realRun() throws InterruptedException {
1113                      await(done);
# Line 1126 | Line 1121 | public class ThreadPoolExecutorTest exte
1121                  } catch (RejectedExecutionException success) {}
1122                  assertTrue(p.getTaskCount() <= 2);
1123              }
1129 –            done.countDown();
1124          }
1125      }
1126  
# Line 1163 | Line 1157 | public class ThreadPoolExecutorTest exte
1157       * executor using DiscardPolicy drops task if saturated.
1158       */
1159      public void testSaturatedExecute3() {
1160 +        final CountDownLatch done = new CountDownLatch(1);
1161          final TrackedNoOpRunnable[] tasks = new TrackedNoOpRunnable[5];
1162          for (int i = 0; i < tasks.length; ++i)
1163              tasks[i] = new TrackedNoOpRunnable();
# Line 1171 | Line 1166 | public class ThreadPoolExecutorTest exte
1166                            LONG_DELAY_MS, MILLISECONDS,
1167                            new ArrayBlockingQueue<Runnable>(1),
1168                            new ThreadPoolExecutor.DiscardPolicy());
1169 <        try (PoolCleaner cleaner = cleaner(p)) {
1175 <            final CountDownLatch done = new CountDownLatch(1);
1169 >        try (PoolCleaner cleaner = cleaner(p, done)) {
1170              p.execute(awaiter(done));
1171  
1172              for (TrackedNoOpRunnable task : tasks)
1173                  p.execute(task);
1174              for (int i = 1; i < tasks.length; i++)
1175                  assertFalse(tasks[i].done);
1182 –            done.countDown();
1176          }
1177          for (int i = 1; i < tasks.length; i++)
1178              assertFalse(tasks[i].done);
# Line 1199 | Line 1192 | public class ThreadPoolExecutorTest exte
1192                                     LONG_DELAY_MS, MILLISECONDS,
1193                                     new ArrayBlockingQueue<Runnable>(1),
1194                                     new ThreadPoolExecutor.DiscardOldestPolicy());
1195 <        try (PoolCleaner cleaner = cleaner(p)) {
1195 >        try (PoolCleaner cleaner = cleaner(p, done)) {
1196              assertEquals(LatchAwaiter.NEW, r1.state);
1197              assertEquals(LatchAwaiter.NEW, r2.state);
1198              assertEquals(LatchAwaiter.NEW, r3.state);
# Line 1209 | Line 1202 | public class ThreadPoolExecutorTest exte
1202              p.execute(r3);
1203              assertFalse(p.getQueue().contains(r2));
1204              assertTrue(p.getQueue().contains(r3));
1212 –            done.countDown();
1205          }
1206          assertEquals(LatchAwaiter.DONE, r1.state);
1207          assertEquals(LatchAwaiter.NEW, r2.state);
# Line 1878 | Line 1870 | public class ThreadPoolExecutorTest exte
1870       * timed invokeAll(c) cancels tasks not completed by timeout
1871       */
1872      public void testTimedInvokeAll6() throws Exception {
1873 <        final ExecutorService e =
1874 <            new ThreadPoolExecutor(2, 2,
1875 <                                   LONG_DELAY_MS, MILLISECONDS,
1876 <                                   new ArrayBlockingQueue<Runnable>(10));
1877 <        try (PoolCleaner cleaner = cleaner(e)) {
1878 <            for (long timeout = timeoutMillis();;) {
1873 >        for (long timeout = timeoutMillis();;) {
1874 >            final CountDownLatch done = new CountDownLatch(1);
1875 >            final Callable<String> waiter = new CheckedCallable<String>() {
1876 >                public String realCall() {
1877 >                    try { done.await(LONG_DELAY_MS, MILLISECONDS); }
1878 >                    catch (InterruptedException ok) {}
1879 >                    return "1"; }};
1880 >            final ExecutorService p =
1881 >                new ThreadPoolExecutor(2, 2,
1882 >                                       LONG_DELAY_MS, MILLISECONDS,
1883 >                                       new ArrayBlockingQueue<Runnable>(10));
1884 >            try (PoolCleaner cleaner = cleaner(p, done)) {
1885                  List<Callable<String>> tasks = new ArrayList<>();
1886                  tasks.add(new StringTask("0"));
1887 <                tasks.add(Executors.callable(new LongPossiblyInterruptedRunnable(), TEST_STRING));
1887 >                tasks.add(waiter);
1888                  tasks.add(new StringTask("2"));
1889                  long startTime = System.nanoTime();
1890                  List<Future<String>> futures =
1891 <                    e.invokeAll(tasks, timeout, MILLISECONDS);
1891 >                    p.invokeAll(tasks, timeout, MILLISECONDS);
1892                  assertEquals(tasks.size(), futures.size());
1893                  assertTrue(millisElapsedSince(startTime) >= timeout);
1894                  for (Future future : futures)
# Line 2028 | Line 2026 | public class ThreadPoolExecutorTest exte
2026       * get(cancelled task) throws CancellationException
2027       */
2028      public void testGet_cancelled() throws Exception {
2029 +        final CountDownLatch done = new CountDownLatch(1);
2030          final ExecutorService e =
2031              new ThreadPoolExecutor(1, 1,
2032                                     LONG_DELAY_MS, MILLISECONDS,
2033                                     new LinkedBlockingQueue<Runnable>());
2034 <        try (PoolCleaner cleaner = cleaner(e)) {
2034 >        try (PoolCleaner cleaner = cleaner(e, done)) {
2035              final CountDownLatch blockerStarted = new CountDownLatch(1);
2037 –            final CountDownLatch done = new CountDownLatch(1);
2036              final List<Future<?>> futures = new ArrayList<>();
2037              for (int i = 0; i < 2; i++) {
2038                  Runnable r = new CheckedRunnable() { public void realRun()
# Line 2058 | Line 2056 | public class ThreadPoolExecutorTest exte
2056                  assertTrue(future.isCancelled());
2057                  assertTrue(future.isDone());
2058              }
2061 –            done.countDown();
2059          }
2060      }
2061  

Diff Legend

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