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.75 by jsr166, Sun Oct 4 02:00:19 2015 UTC vs.
Revision 1.81 by jsr166, Sun Oct 4 02:24:49 2015 UTC

# Line 87 | Line 87 | public class ThreadPoolExecutorTest exte
87              new ThreadPoolExecutor(1, 1,
88                                     LONG_DELAY_MS, MILLISECONDS,
89                                     new ArrayBlockingQueue<Runnable>(10));
90 <        final CountDownLatch done = new CountDownLatch(1);
91 <        final Runnable task = new CheckedRunnable() {
92 <            public void realRun() {
93 <                done.countDown();
94 <            }};
95 <        try {
90 >        try (PoolCleaner cleaner = cleaner(p)) {
91 >            final CountDownLatch done = new CountDownLatch(1);
92 >            final Runnable task = new CheckedRunnable() {
93 >                public void realRun() { done.countDown(); }};
94              p.execute(task);
95 <            assertTrue(done.await(SMALL_DELAY_MS, MILLISECONDS));
98 <        } finally {
99 <            joinPool(p);
95 >            assertTrue(done.await(LONG_DELAY_MS, MILLISECONDS));
96          }
97      }
98  
# Line 109 | Line 105 | public class ThreadPoolExecutorTest exte
105              new ThreadPoolExecutor(2, 2,
106                                     LONG_DELAY_MS, MILLISECONDS,
107                                     new ArrayBlockingQueue<Runnable>(10));
108 <        final CountDownLatch threadStarted = new CountDownLatch(1);
109 <        final CountDownLatch done = new CountDownLatch(1);
110 <        try {
108 >        try (PoolCleaner cleaner = cleaner(p)) {
109 >            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 119 | Line 115 | public class ThreadPoolExecutorTest exte
115                      assertEquals(1, p.getActiveCount());
116                      done.await();
117                  }});
118 <            assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
118 >            assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
119              assertEquals(1, p.getActiveCount());
124 –        } finally {
120              done.countDown();
126 –            joinPool(p);
121          }
122      }
123  
# Line 339 | Line 333 | public class ThreadPoolExecutorTest exte
333              new ThreadPoolExecutor(THREADS, THREADS,
334                                     LONG_DELAY_MS, MILLISECONDS,
335                                     new ArrayBlockingQueue<Runnable>(10));
336 <        final CountDownLatch threadsStarted = new CountDownLatch(THREADS);
337 <        final CountDownLatch done = new CountDownLatch(1);
338 <        try {
336 >        try (PoolCleaner cleaner = cleaner(p)) {
337 >            final CountDownLatch threadsStarted = new CountDownLatch(THREADS);
338 >            final CountDownLatch done = new CountDownLatch(1);
339              assertEquals(0, p.getLargestPoolSize());
340              for (int i = 0; i < THREADS; i++)
341                  p.execute(new CheckedRunnable() {
# Line 350 | Line 344 | public class ThreadPoolExecutorTest exte
344                          done.await();
345                          assertEquals(THREADS, p.getLargestPoolSize());
346                      }});
347 <            assertTrue(threadsStarted.await(SMALL_DELAY_MS, MILLISECONDS));
354 <            assertEquals(THREADS, p.getLargestPoolSize());
355 <        } finally {
356 <            done.countDown();
357 <            joinPool(p);
347 >            assertTrue(threadsStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
348              assertEquals(THREADS, p.getLargestPoolSize());
349 +            done.countDown();   // release pool
350          }
351 +        assertEquals(THREADS, p.getLargestPoolSize());
352      }
353  
354      /**
# Line 368 | Line 360 | public class ThreadPoolExecutorTest exte
360              new ThreadPoolExecutor(2, 3,
361                                     LONG_DELAY_MS, MILLISECONDS,
362                                     new ArrayBlockingQueue<Runnable>(10));
363 <        assertEquals(3, p.getMaximumPoolSize());
364 <        joinPool(p);
363 >        try (PoolCleaner cleaner = cleaner(p)) {
364 >            assertEquals(3, p.getMaximumPoolSize());
365 >            p.setMaximumPoolSize(5);
366 >            assertEquals(5, p.getMaximumPoolSize());
367 >            p.setMaximumPoolSize(4);
368 >            assertEquals(4, p.getMaximumPoolSize());
369 >        }
370      }
371  
372      /**
# Line 381 | Line 378 | public class ThreadPoolExecutorTest exte
378              new ThreadPoolExecutor(1, 1,
379                                     LONG_DELAY_MS, MILLISECONDS,
380                                     new ArrayBlockingQueue<Runnable>(10));
381 <        final CountDownLatch threadStarted = new CountDownLatch(1);
382 <        final CountDownLatch done = new CountDownLatch(1);
383 <        try {
381 >        try (PoolCleaner cleaner = cleaner(p)) {
382 >            final CountDownLatch threadStarted = new CountDownLatch(1);
383 >            final CountDownLatch done = new CountDownLatch(1);
384              assertEquals(0, p.getPoolSize());
385              p.execute(new CheckedRunnable() {
386                  public void realRun() throws InterruptedException {
# Line 391 | Line 388 | public class ThreadPoolExecutorTest exte
388                      assertEquals(1, p.getPoolSize());
389                      done.await();
390                  }});
391 <            assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
391 >            assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
392              assertEquals(1, p.getPoolSize());
393 <        } finally {
397 <            done.countDown();
398 <            joinPool(p);
393 >            done.countDown();   // release pool
394          }
395      }
396  
# Line 407 | Line 402 | public class ThreadPoolExecutorTest exte
402              new ThreadPoolExecutor(1, 1,
403                                     LONG_DELAY_MS, MILLISECONDS,
404                                     new ArrayBlockingQueue<Runnable>(10));
405 <        final CountDownLatch threadStarted = new CountDownLatch(1);
406 <        final CountDownLatch done = new CountDownLatch(1);
407 <        try {
405 >        try (PoolCleaner cleaner = cleaner(p)) {
406 >            final CountDownLatch threadStarted = new CountDownLatch(1);
407 >            final CountDownLatch done = new CountDownLatch(1);
408              assertEquals(0, p.getTaskCount());
409              p.execute(new CheckedRunnable() {
410                  public void realRun() throws InterruptedException {
# Line 417 | Line 412 | public class ThreadPoolExecutorTest exte
412                      assertEquals(1, p.getTaskCount());
413                      done.await();
414                  }});
415 <            assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
415 >            assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
416              assertEquals(1, p.getTaskCount());
422 –        } finally {
417              done.countDown();
424 –            joinPool(p);
418          }
419      }
420  
# Line 487 | Line 480 | public class ThreadPoolExecutorTest exte
480                      threadStarted.countDown();
481                      done.await();
482                  }});
483 <            assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
483 >            assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
484              assertFalse(p.isTerminating());
485              done.countDown();
486          } finally {
# Line 515 | Line 508 | public class ThreadPoolExecutorTest exte
508                      threadStarted.countDown();
509                      done.await();
510                  }});
511 <            assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
511 >            assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
512              assertFalse(p.isTerminating());
513              done.countDown();
514          } finally {
# Line 550 | Line 543 | public class ThreadPoolExecutorTest exte
543                  tasks[i] = new FutureTask(task);
544                  p.execute(tasks[i]);
545              }
546 <            assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
546 >            assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
547              assertSame(q, p.getQueue());
548              assertFalse(q.contains(tasks[0]));
549              assertTrue(q.contains(tasks[tasks.length - 1]));
# Line 582 | Line 575 | public class ThreadPoolExecutorTest exte
575                      }};
576                  p.execute(tasks[i]);
577              }
578 <            assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
578 >            assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
579              assertFalse(p.remove(tasks[0]));
580              assertTrue(q.contains(tasks[4]));
581              assertTrue(q.contains(tasks[3]));
# Line 621 | Line 614 | public class ThreadPoolExecutorTest exte
614                  tasks[i] = new FutureTask(task);
615                  p.execute(tasks[i]);
616              }
617 <            assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
617 >            assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
618              assertEquals(tasks.length, p.getTaskCount());
619              assertEquals(tasks.length - 1, q.size());
620              assertEquals(1L, p.getActiveCount());
# Line 1043 | Line 1036 | public class ThreadPoolExecutorTest exte
1036                      p.submit(task).get();
1037                  }});
1038  
1039 <            assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
1039 >            assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
1040              t.interrupt();
1041              awaitTermination(t, MEDIUM_DELAY_MS);
1042          } finally {

Diff Legend

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