1 /* 2 * Written by Doug Lea with assistance from members of JCP JSR-166 3 * Expert Group and released to the public domain, as explained at 4 * http://creativecommons.org/publicdomain/zero/1.0/ 5 * Other contributors include Andrew Wright, Jeffrey Hayes, 6 * Pat Fisher, Mike Judd. 7 */ 8 9 package jsr166; 10 11 import junit.framework.*; 12 import java.util.concurrent.*; 13 import static java.util.concurrent.TimeUnit.MILLISECONDS; 14 import static java.util.concurrent.TimeUnit.NANOSECONDS; 15 import java.util.*; 16 17 public class ThreadPoolExecutorTest extends JSR166TestCase { 18 19 static class ExtendedTPE extends ThreadPoolExecutor { 20 final CountDownLatch beforeCalled = new CountDownLatch(1); 21 final CountDownLatch afterCalled = new CountDownLatch(1); 22 final CountDownLatch terminatedCalled = new CountDownLatch(1); 23 24 public ExtendedTPE() { 25 super(1, 1, LONG_DELAY_MS, MILLISECONDS, new SynchronousQueue<Runnable>()); 26 } 27 protected void beforeExecute(Thread t, Runnable r) { 28 beforeCalled.countDown(); 29 } 30 protected void afterExecute(Runnable r, Throwable t) { 31 afterCalled.countDown(); 32 } 33 protected void terminated() { 34 terminatedCalled.countDown(); 35 } 36 37 public boolean beforeCalled() { 38 return beforeCalled.getCount() == 0; 39 } 40 public boolean afterCalled() { 41 return afterCalled.getCount() == 0; 42 } 43 public boolean terminatedCalled() { 44 return terminatedCalled.getCount() == 0; 45 } 46 } 47 48 static class FailingThreadFactory implements ThreadFactory { 49 int calls = 0; 50 public Thread newThread(Runnable r) { 51 if (++calls > 1) return null; 52 return new Thread(r); 53 } 54 } 55 56 /** 57 * execute successfully executes a runnable 58 */ 59 public void testExecute() throws InterruptedException { 60 final ThreadPoolExecutor p = 61 new ThreadPoolExecutor(1, 1, 62 LONG_DELAY_MS, MILLISECONDS, 63 new ArrayBlockingQueue<Runnable>(10)); 64 final CountDownLatch done = new CountDownLatch(1); 65 final Runnable task = new CheckedRunnable() { 66 public void realRun() { 67 done.countDown(); 68 }}; 69 try { 70 p.execute(task); 71 assertTrue(done.await(SMALL_DELAY_MS, MILLISECONDS)); 72 } finally { 73 joinPool(p); 74 } 75 } 76 77 /** 78 * getActiveCount increases but doesn't overestimate, when a 79 * thread becomes active 80 */ 81 public void testGetActiveCount() throws InterruptedException { 82 final ThreadPoolExecutor p = 83 new ThreadPoolExecutor(2, 2, 84 LONG_DELAY_MS, MILLISECONDS, 85 new ArrayBlockingQueue<Runnable>(10)); 86 final CountDownLatch threadStarted = new CountDownLatch(1); 87 final CountDownLatch done = new CountDownLatch(1); 88 try { 89 assertEquals(0, p.getActiveCount()); 90 p.execute(new CheckedRunnable() { 91 public void realRun() throws InterruptedException { 92 threadStarted.countDown(); 93 assertEquals(1, p.getActiveCount()); 94 done.await(); 95 }}); 96 assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS)); 97 assertEquals(1, p.getActiveCount()); 98 } finally { 99 done.countDown(); 100 joinPool(p); 101 } 102 } 103 104 /** 105 * prestartCoreThread starts a thread if under corePoolSize, else doesn't 106 */ 107 public void testPrestartCoreThread() { 108 final ThreadPoolExecutor p = 109 new ThreadPoolExecutor(2, 2, 110 LONG_DELAY_MS, MILLISECONDS, 111 new ArrayBlockingQueue<Runnable>(10)); 112 assertEquals(0, p.getPoolSize()); 113 assertTrue(p.prestartCoreThread()); 114 assertEquals(1, p.getPoolSize()); 115 assertTrue(p.prestartCoreThread()); 116 assertEquals(2, p.getPoolSize()); 117 assertFalse(p.prestartCoreThread()); 118 assertEquals(2, p.getPoolSize()); 119 joinPool(p); 120 } 121 122 /** 123 * prestartAllCoreThreads starts all corePoolSize threads 124 */ 125 public void testPrestartAllCoreThreads() { 126 final ThreadPoolExecutor p = 127 new ThreadPoolExecutor(2, 2, 128 LONG_DELAY_MS, MILLISECONDS, 129 new ArrayBlockingQueue<Runnable>(10)); 130 assertEquals(0, p.getPoolSize()); 131 p.prestartAllCoreThreads(); 132 assertEquals(2, p.getPoolSize()); 133 p.prestartAllCoreThreads(); 134 assertEquals(2, p.getPoolSize()); 135 joinPool(p); 136 } 137 138 /** 139 * getCompletedTaskCount increases, but doesn't overestimate, 140 * when tasks complete 141 */ 142 public void testGetCompletedTaskCount() throws InterruptedException { 143 final ThreadPoolExecutor p = 144 new ThreadPoolExecutor(2, 2, 145 LONG_DELAY_MS, MILLISECONDS, 146 new ArrayBlockingQueue<Runnable>(10)); 147 final CountDownLatch threadStarted = new CountDownLatch(1); 148 final CountDownLatch threadProceed = new CountDownLatch(1); 149 final CountDownLatch threadDone = new CountDownLatch(1); 150 try { 151 assertEquals(0, p.getCompletedTaskCount()); 152 p.execute(new CheckedRunnable() { 153 public void realRun() throws InterruptedException { 154 threadStarted.countDown(); 155 assertEquals(0, p.getCompletedTaskCount()); 156 threadProceed.await(); 157 threadDone.countDown(); 158 }}); 159 await(threadStarted); 160 assertEquals(0, p.getCompletedTaskCount()); 161 threadProceed.countDown(); 162 threadDone.await(); 163 long startTime = System.nanoTime(); 164 while (p.getCompletedTaskCount() != 1) { 165 if (millisElapsedSince(startTime) > LONG_DELAY_MS) 166 fail("timed out"); 167 Thread.yield(); 168 } 169 } finally { 170 joinPool(p); 171 } 172 } 173 174 /** 175 * getCorePoolSize returns size given in constructor if not otherwise set 176 */ 177 public void testGetCorePoolSize() { 178 final ThreadPoolExecutor p = 179 new ThreadPoolExecutor(1, 1, 180 LONG_DELAY_MS, MILLISECONDS, 181 new ArrayBlockingQueue<Runnable>(10)); 182 assertEquals(1, p.getCorePoolSize()); 183 joinPool(p); 184 } 185 186 /** 187 * getKeepAliveTime returns value given in constructor if not otherwise set 188 */ 189 public void testGetKeepAliveTime() { 190 final ThreadPoolExecutor p = 191 new ThreadPoolExecutor(2, 2, 192 1000, MILLISECONDS, 193 new ArrayBlockingQueue<Runnable>(10)); 194 assertEquals(1, p.getKeepAliveTime(TimeUnit.SECONDS)); 195 joinPool(p); 196 } 197 198 /** 199 * getThreadFactory returns factory in constructor if not set 200 */ 201 public void testGetThreadFactory() { 202 ThreadFactory tf = new SimpleThreadFactory(); 203 final ThreadPoolExecutor p = 204 new ThreadPoolExecutor(1, 2, 205 LONG_DELAY_MS, MILLISECONDS, 206 new ArrayBlockingQueue<Runnable>(10), 207 tf, 208 new NoOpREHandler()); 209 assertSame(tf, p.getThreadFactory()); 210 joinPool(p); 211 } 212 213 /** 214 * setThreadFactory sets the thread factory returned by getThreadFactory 215 */ 216 public void testSetThreadFactory() { 217 final ThreadPoolExecutor p = 218 new ThreadPoolExecutor(1, 2, 219 LONG_DELAY_MS, MILLISECONDS, 220 new ArrayBlockingQueue<Runnable>(10)); 221 ThreadFactory tf = new SimpleThreadFactory(); 222 p.setThreadFactory(tf); 223 assertSame(tf, p.getThreadFactory()); 224 joinPool(p); 225 } 226 227 /** 228 * setThreadFactory(null) throws NPE 229 */ 230 public void testSetThreadFactoryNull() { 231 final ThreadPoolExecutor p = 232 new ThreadPoolExecutor(1, 2, 233 LONG_DELAY_MS, MILLISECONDS, 234 new ArrayBlockingQueue<Runnable>(10)); 235 try { 236 p.setThreadFactory(null); 237 shouldThrow(); 238 } catch (NullPointerException success) { 239 } finally { 240 joinPool(p); 241 } 242 } 243 244 /** 245 * getRejectedExecutionHandler returns handler in constructor if not set 246 */ 247 public void testGetRejectedExecutionHandler() { 248 final RejectedExecutionHandler h = new NoOpREHandler(); 249 final ThreadPoolExecutor p = 250 new ThreadPoolExecutor(1, 2, 251 LONG_DELAY_MS, MILLISECONDS, 252 new ArrayBlockingQueue<Runnable>(10), 253 h); 254 assertSame(h, p.getRejectedExecutionHandler()); 255 joinPool(p); 256 } 257 258 /** 259 * setRejectedExecutionHandler sets the handler returned by 260 * getRejectedExecutionHandler 261 */ 262 public void testSetRejectedExecutionHandler() { 263 final ThreadPoolExecutor p = 264 new ThreadPoolExecutor(1, 2, 265 LONG_DELAY_MS, MILLISECONDS, 266 new ArrayBlockingQueue<Runnable>(10)); 267 RejectedExecutionHandler h = new NoOpREHandler(); 268 p.setRejectedExecutionHandler(h); 269 assertSame(h, p.getRejectedExecutionHandler()); 270 joinPool(p); 271 } 272 273 /** 274 * setRejectedExecutionHandler(null) throws NPE 275 */ 276 public void testSetRejectedExecutionHandlerNull() { 277 final ThreadPoolExecutor p = 278 new ThreadPoolExecutor(1, 2, 279 LONG_DELAY_MS, MILLISECONDS, 280 new ArrayBlockingQueue<Runnable>(10)); 281 try { 282 p.setRejectedExecutionHandler(null); 283 shouldThrow(); 284 } catch (NullPointerException success) { 285 } finally { 286 joinPool(p); 287 } 288 } 289 290 /** 291 * getLargestPoolSize increases, but doesn't overestimate, when 292 * multiple threads active 293 */ 294 public void testGetLargestPoolSize() throws InterruptedException { 295 final int THREADS = 3; 296 final ThreadPoolExecutor p = 297 new ThreadPoolExecutor(THREADS, THREADS, 298 LONG_DELAY_MS, MILLISECONDS, 299 new ArrayBlockingQueue<Runnable>(10)); 300 final CountDownLatch threadsStarted = new CountDownLatch(THREADS); 301 final CountDownLatch done = new CountDownLatch(1); 302 try { 303 assertEquals(0, p.getLargestPoolSize()); 304 for (int i = 0; i < THREADS; i++) 305 p.execute(new CheckedRunnable() { 306 public void realRun() throws InterruptedException { 307 threadsStarted.countDown(); 308 done.await(); 309 assertEquals(THREADS, p.getLargestPoolSize()); 310 }}); 311 assertTrue(threadsStarted.await(SMALL_DELAY_MS, MILLISECONDS)); 312 assertEquals(THREADS, p.getLargestPoolSize()); 313 } finally { 314 done.countDown(); 315 joinPool(p); 316 assertEquals(THREADS, p.getLargestPoolSize()); 317 } 318 } 319 320 /** 321 * getMaximumPoolSize returns value given in constructor if not 322 * otherwise set 323 */ 324 public void testGetMaximumPoolSize() { 325 final ThreadPoolExecutor p = 326 new ThreadPoolExecutor(2, 3, 327 LONG_DELAY_MS, MILLISECONDS, 328 new ArrayBlockingQueue<Runnable>(10)); 329 assertEquals(3, p.getMaximumPoolSize()); 330 joinPool(p); 331 } 332 333 /** 334 * getPoolSize increases, but doesn't overestimate, when threads 335 * become active 336 */ 337 public void testGetPoolSize() throws InterruptedException { 338 final ThreadPoolExecutor p = 339 new ThreadPoolExecutor(1, 1, 340 LONG_DELAY_MS, MILLISECONDS, 341 new ArrayBlockingQueue<Runnable>(10)); 342 final CountDownLatch threadStarted = new CountDownLatch(1); 343 final CountDownLatch done = new CountDownLatch(1); 344 try { 345 assertEquals(0, p.getPoolSize()); 346 p.execute(new CheckedRunnable() { 347 public void realRun() throws InterruptedException { 348 threadStarted.countDown(); 349 assertEquals(1, p.getPoolSize()); 350 done.await(); 351 }}); 352 assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS)); 353 assertEquals(1, p.getPoolSize()); 354 } finally { 355 done.countDown(); 356 joinPool(p); 357 } 358 } 359 360 /** 361 * getTaskCount increases, but doesn't overestimate, when tasks submitted 362 */ 363 public void testGetTaskCount() throws InterruptedException { 364 final ThreadPoolExecutor p = 365 new ThreadPoolExecutor(1, 1, 366 LONG_DELAY_MS, MILLISECONDS, 367 new ArrayBlockingQueue<Runnable>(10)); 368 final CountDownLatch threadStarted = new CountDownLatch(1); 369 final CountDownLatch done = new CountDownLatch(1); 370 try { 371 assertEquals(0, p.getTaskCount()); 372 p.execute(new CheckedRunnable() { 373 public void realRun() throws InterruptedException { 374 threadStarted.countDown(); 375 assertEquals(1, p.getTaskCount()); 376 done.await(); 377 }}); 378 assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS)); 379 assertEquals(1, p.getTaskCount()); 380 } finally { 381 done.countDown(); 382 joinPool(p); 383 } 384 } 385 386 /** 387 * isShutdown is false before shutdown, true after 388 */ 389 public void testIsShutdown() { 390 final ThreadPoolExecutor p = 391 new ThreadPoolExecutor(1, 1, 392 LONG_DELAY_MS, MILLISECONDS, 393 new ArrayBlockingQueue<Runnable>(10)); 394 assertFalse(p.isShutdown()); 395 try { p.shutdown(); } catch (SecurityException ok) { return; } 396 assertTrue(p.isShutdown()); 397 joinPool(p); 398 } 399 400 /** 401 * awaitTermination on a non-shutdown pool times out 402 */ 403 public void testAwaitTermination_timesOut() throws InterruptedException { 404 final ThreadPoolExecutor p = 405 new ThreadPoolExecutor(1, 1, 406 LONG_DELAY_MS, MILLISECONDS, 407 new ArrayBlockingQueue<Runnable>(10)); 408 assertFalse(p.isTerminated()); 409 assertFalse(p.awaitTermination(Long.MIN_VALUE, NANOSECONDS)); 410 assertFalse(p.awaitTermination(Long.MIN_VALUE, MILLISECONDS)); 411 assertFalse(p.awaitTermination(-1L, NANOSECONDS)); 412 assertFalse(p.awaitTermination(-1L, MILLISECONDS)); 413 assertFalse(p.awaitTermination(0L, NANOSECONDS)); 414 assertFalse(p.awaitTermination(0L, MILLISECONDS)); 415 long timeoutNanos = 999999L; 416 long startTime = System.nanoTime(); 417 assertFalse(p.awaitTermination(timeoutNanos, NANOSECONDS)); 418 assertTrue(System.nanoTime() - startTime >= timeoutNanos); 419 assertFalse(p.isTerminated()); 420 startTime = System.nanoTime(); 421 long timeoutMillis = timeoutMillis(); 422 assertFalse(p.awaitTermination(timeoutMillis, MILLISECONDS)); 423 assertTrue(millisElapsedSince(startTime) >= timeoutMillis); 424 assertFalse(p.isTerminated()); 425 p.shutdown(); 426 assertTrue(p.awaitTermination(LONG_DELAY_MS, MILLISECONDS)); 427 assertTrue(p.isTerminated()); 428 } 429 430 /** 431 * isTerminated is false before termination, true after 432 */ 433 public void testIsTerminated() throws InterruptedException { 434 final ThreadPoolExecutor p = 435 new ThreadPoolExecutor(1, 1, 436 LONG_DELAY_MS, MILLISECONDS, 437 new ArrayBlockingQueue<Runnable>(10)); 438 final CountDownLatch threadStarted = new CountDownLatch(1); 439 final CountDownLatch done = new CountDownLatch(1); 440 assertFalse(p.isTerminated()); 441 try { 442 p.execute(new CheckedRunnable() { 443 public void realRun() throws InterruptedException { 444 assertFalse(p.isTerminated()); 445 threadStarted.countDown(); 446 done.await(); 447 }}); 448 assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS)); 449 assertFalse(p.isTerminating()); 450 done.countDown(); 451 } finally { 452 try { p.shutdown(); } catch (SecurityException ok) { return; } 453 } 454 assertTrue(p.awaitTermination(LONG_DELAY_MS, MILLISECONDS)); 455 assertTrue(p.isTerminated()); 456 } 457 458 /** 459 * isTerminating is not true when running or when terminated 460 */ 461 public void testIsTerminating() throws InterruptedException { 462 final ThreadPoolExecutor p = 463 new ThreadPoolExecutor(1, 1, 464 LONG_DELAY_MS, MILLISECONDS, 465 new ArrayBlockingQueue<Runnable>(10)); 466 final CountDownLatch threadStarted = new CountDownLatch(1); 467 final CountDownLatch done = new CountDownLatch(1); 468 try { 469 assertFalse(p.isTerminating()); 470 p.execute(new CheckedRunnable() { 471 public void realRun() throws InterruptedException { 472 assertFalse(p.isTerminating()); 473 threadStarted.countDown(); 474 done.await(); 475 }}); 476 assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS)); 477 assertFalse(p.isTerminating()); 478 done.countDown(); 479 } finally { 480 try { p.shutdown(); } catch (SecurityException ok) { return; } 481 } 482 assertTrue(p.awaitTermination(LONG_DELAY_MS, MILLISECONDS)); 483 assertTrue(p.isTerminated()); 484 assertFalse(p.isTerminating()); 485 } 486 487 /** 488 * getQueue returns the work queue, which contains queued tasks 489 */ 490 public void testGetQueue() throws InterruptedException { 491 final BlockingQueue<Runnable> q = new ArrayBlockingQueue<Runnable>(10); 492 final ThreadPoolExecutor p = 493 new ThreadPoolExecutor(1, 1, 494 LONG_DELAY_MS, MILLISECONDS, 495 q); 496 final CountDownLatch threadStarted = new CountDownLatch(1); 497 final CountDownLatch done = new CountDownLatch(1); 498 try { 499 FutureTask[] tasks = new FutureTask[5]; 500 for (int i = 0; i < tasks.length; i++) { 501 Callable task = new CheckedCallable<Boolean>() { 502 public Boolean realCall() throws InterruptedException { 503 threadStarted.countDown(); 504 assertSame(q, p.getQueue()); 505 done.await(); 506 return Boolean.TRUE; 507 }}; 508 tasks[i] = new FutureTask(task); 509 p.execute(tasks[i]); 510 } 511 assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS)); 512 assertSame(q, p.getQueue()); 513 assertFalse(q.contains(tasks[0])); 514 assertTrue(q.contains(tasks[tasks.length - 1])); 515 assertEquals(tasks.length - 1, q.size()); 516 } finally { 517 done.countDown(); 518 joinPool(p); 519 } 520 } 521 522 /** 523 * remove(task) removes queued task, and fails to remove active task 524 */ 525 public void testRemove() throws InterruptedException { 526 BlockingQueue<Runnable> q = new ArrayBlockingQueue<Runnable>(10); 527 final ThreadPoolExecutor p = 528 new ThreadPoolExecutor(1, 1, 529 LONG_DELAY_MS, MILLISECONDS, 530 q); 531 Runnable[] tasks = new Runnable[5]; 532 final CountDownLatch threadStarted = new CountDownLatch(1); 533 final CountDownLatch done = new CountDownLatch(1); 534 try { 535 for (int i = 0; i < tasks.length; i++) { 536 tasks[i] = new CheckedRunnable() { 537 public void realRun() throws InterruptedException { 538 threadStarted.countDown(); 539 done.await(); 540 }}; 541 p.execute(tasks[i]); 542 } 543 assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS)); 544 assertFalse(p.remove(tasks[0])); 545 assertTrue(q.contains(tasks[4])); 546 assertTrue(q.contains(tasks[3])); 547 assertTrue(p.remove(tasks[4])); 548 assertFalse(p.remove(tasks[4])); 549 assertFalse(q.contains(tasks[4])); 550 assertTrue(q.contains(tasks[3])); 551 assertTrue(p.remove(tasks[3])); 552 assertFalse(q.contains(tasks[3])); 553 } finally { 554 done.countDown(); 555 joinPool(p); 556 } 557 } 558 559 /** 560 * purge removes cancelled tasks from the queue 561 */ 562 public void testPurge() throws InterruptedException { 563 final CountDownLatch threadStarted = new CountDownLatch(1); 564 final CountDownLatch done = new CountDownLatch(1); 565 final BlockingQueue<Runnable> q = new ArrayBlockingQueue<Runnable>(10); 566 final ThreadPoolExecutor p = 567 new ThreadPoolExecutor(1, 1, 568 LONG_DELAY_MS, MILLISECONDS, 569 q); 570 FutureTask[] tasks = new FutureTask[5]; 571 try { 572 for (int i = 0; i < tasks.length; i++) { 573 Callable task = new CheckedCallable<Boolean>() { 574 public Boolean realCall() throws InterruptedException { 575 threadStarted.countDown(); 576 done.await(); 577 return Boolean.TRUE; 578 }}; 579 tasks[i] = new FutureTask(task); 580 p.execute(tasks[i]); 581 } 582 assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS)); 583 assertEquals(tasks.length, p.getTaskCount()); 584 assertEquals(tasks.length - 1, q.size()); 585 assertEquals(1L, p.getActiveCount()); 586 assertEquals(0L, p.getCompletedTaskCount()); 587 tasks[4].cancel(true); 588 tasks[3].cancel(false); 589 p.purge(); 590 assertEquals(tasks.length - 3, q.size()); 591 assertEquals(tasks.length - 2, p.getTaskCount()); 592 p.purge(); // Nothing to do 593 assertEquals(tasks.length - 3, q.size()); 594 assertEquals(tasks.length - 2, p.getTaskCount()); 595 } finally { 596 done.countDown(); 597 joinPool(p); 598 } 599 } 600 601 /** 602 * shutdownNow returns a list containing tasks that were not run 603 */ 604 public void testShutdownNow() { 605 final ThreadPoolExecutor p = 606 new ThreadPoolExecutor(1, 1, 607 LONG_DELAY_MS, MILLISECONDS, 608 new ArrayBlockingQueue<Runnable>(10)); 609 List l; 610 try { 611 for (int i = 0; i < 5; i++) 612 p.execute(new MediumPossiblyInterruptedRunnable()); 613 } 614 finally { 615 try { 616 l = p.shutdownNow(); 617 } catch (SecurityException ok) { return; } 618 } 619 assertTrue(p.isShutdown()); 620 assertTrue(l.size() <= 4); 621 } 622 623 // Exception Tests 624 625 /** 626 * Constructor throws if corePoolSize argument is less than zero 627 */ 628 public void testConstructor1() { 629 try { 630 new ThreadPoolExecutor(-1, 1, 631 LONG_DELAY_MS, MILLISECONDS, 632 new ArrayBlockingQueue<Runnable>(10)); 633 shouldThrow(); 634 } catch (IllegalArgumentException success) {} 635 } 636 637 /** 638 * Constructor throws if maximumPoolSize is less than zero 639 */ 640 public void testConstructor2() { 641 try { 642 new ThreadPoolExecutor(1, -1, 643 LONG_DELAY_MS, MILLISECONDS, 644 new ArrayBlockingQueue<Runnable>(10)); 645 shouldThrow(); 646 } catch (IllegalArgumentException success) {} 647 } 648 649 /** 650 * Constructor throws if maximumPoolSize is equal to zero 651 */ 652 public void testConstructor3() { 653 try { 654 new ThreadPoolExecutor(1, 0, 655 LONG_DELAY_MS, MILLISECONDS, 656 new ArrayBlockingQueue<Runnable>(10)); 657 shouldThrow(); 658 } catch (IllegalArgumentException success) {} 659 } 660 661 /** 662 * Constructor throws if keepAliveTime is less than zero 663 */ 664 public void testConstructor4() { 665 try { 666 new ThreadPoolExecutor(1, 2, 667 -1L, MILLISECONDS, 668 new ArrayBlockingQueue<Runnable>(10)); 669 shouldThrow(); 670 } catch (IllegalArgumentException success) {} 671 } 672 673 /** 674 * Constructor throws if corePoolSize is greater than the maximumPoolSize 675 */ 676 public void testConstructor5() { 677 try { 678 new ThreadPoolExecutor(2, 1, 679 LONG_DELAY_MS, MILLISECONDS, 680 new ArrayBlockingQueue<Runnable>(10)); 681 shouldThrow(); 682 } catch (IllegalArgumentException success) {} 683 } 684 685 /** 686 * Constructor throws if workQueue is set to null 687 */ 688 public void testConstructorNullPointerException() { 689 try { 690 new ThreadPoolExecutor(1, 2, 691 LONG_DELAY_MS, MILLISECONDS, 692 (BlockingQueue) null); 693 shouldThrow(); 694 } catch (NullPointerException success) {} 695 } 696 697 /** 698 * Constructor throws if corePoolSize argument is less than zero 699 */ 700 public void testConstructor6() { 701 try { 702 new ThreadPoolExecutor(-1, 1, 703 LONG_DELAY_MS, MILLISECONDS, 704 new ArrayBlockingQueue<Runnable>(10), 705 new SimpleThreadFactory()); 706 shouldThrow(); 707 } catch (IllegalArgumentException success) {} 708 } 709 710 /** 711 * Constructor throws if maximumPoolSize is less than zero 712 */ 713 public void testConstructor7() { 714 try { 715 new ThreadPoolExecutor(1, -1, 716 LONG_DELAY_MS, MILLISECONDS, 717 new ArrayBlockingQueue<Runnable>(10), 718 new SimpleThreadFactory()); 719 shouldThrow(); 720 } catch (IllegalArgumentException success) {} 721 } 722 723 /** 724 * Constructor throws if maximumPoolSize is equal to zero 725 */ 726 public void testConstructor8() { 727 try { 728 new ThreadPoolExecutor(1, 0, 729 LONG_DELAY_MS, MILLISECONDS, 730 new ArrayBlockingQueue<Runnable>(10), 731 new SimpleThreadFactory()); 732 shouldThrow(); 733 } catch (IllegalArgumentException success) {} 734 } 735 736 /** 737 * Constructor throws if keepAliveTime is less than zero 738 */ 739 public void testConstructor9() { 740 try { 741 new ThreadPoolExecutor(1, 2, 742 -1L, MILLISECONDS, 743 new ArrayBlockingQueue<Runnable>(10), 744 new SimpleThreadFactory()); 745 shouldThrow(); 746 } catch (IllegalArgumentException success) {} 747 } 748 749 /** 750 * Constructor throws if corePoolSize is greater than the maximumPoolSize 751 */ 752 public void testConstructor10() { 753 try { 754 new ThreadPoolExecutor(2, 1, 755 LONG_DELAY_MS, MILLISECONDS, 756 new ArrayBlockingQueue<Runnable>(10), 757 new SimpleThreadFactory()); 758 shouldThrow(); 759 } catch (IllegalArgumentException success) {} 760 } 761 762 /** 763 * Constructor throws if workQueue is set to null 764 */ 765 public void testConstructorNullPointerException2() { 766 try { 767 new ThreadPoolExecutor(1, 2, 768 LONG_DELAY_MS, MILLISECONDS, 769 (BlockingQueue) null, 770 new SimpleThreadFactory()); 771 shouldThrow(); 772 } catch (NullPointerException success) {} 773 } 774 775 /** 776 * Constructor throws if threadFactory is set to null 777 */ 778 public void testConstructorNullPointerException3() { 779 try { 780 new ThreadPoolExecutor(1, 2, 781 LONG_DELAY_MS, MILLISECONDS, 782 new ArrayBlockingQueue<Runnable>(10), 783 (ThreadFactory) null); 784 shouldThrow(); 785 } catch (NullPointerException success) {} 786 } 787 788 /** 789 * Constructor throws if corePoolSize argument is less than zero 790 */ 791 public void testConstructor11() { 792 try { 793 new ThreadPoolExecutor(-1, 1, 794 LONG_DELAY_MS, MILLISECONDS, 795 new ArrayBlockingQueue<Runnable>(10), 796 new NoOpREHandler()); 797 shouldThrow(); 798 } catch (IllegalArgumentException success) {} 799 } 800 801 /** 802 * Constructor throws if maximumPoolSize is less than zero 803 */ 804 public void testConstructor12() { 805 try { 806 new ThreadPoolExecutor(1, -1, 807 LONG_DELAY_MS, MILLISECONDS, 808 new ArrayBlockingQueue<Runnable>(10), 809 new NoOpREHandler()); 810 shouldThrow(); 811 } catch (IllegalArgumentException success) {} 812 } 813 814 /** 815 * Constructor throws if maximumPoolSize is equal to zero 816 */ 817 public void testConstructor13() { 818 try { 819 new ThreadPoolExecutor(1, 0, 820 LONG_DELAY_MS, MILLISECONDS, 821 new ArrayBlockingQueue<Runnable>(10), 822 new NoOpREHandler()); 823 shouldThrow(); 824 } catch (IllegalArgumentException success) {} 825 } 826 827 /** 828 * Constructor throws if keepAliveTime is less than zero 829 */ 830 public void testConstructor14() { 831 try { 832 new ThreadPoolExecutor(1, 2, 833 -1L, MILLISECONDS, 834 new ArrayBlockingQueue<Runnable>(10), 835 new NoOpREHandler()); 836 shouldThrow(); 837 } catch (IllegalArgumentException success) {} 838 } 839 840 /** 841 * Constructor throws if corePoolSize is greater than the maximumPoolSize 842 */ 843 public void testConstructor15() { 844 try { 845 new ThreadPoolExecutor(2, 1, 846 LONG_DELAY_MS, MILLISECONDS, 847 new ArrayBlockingQueue<Runnable>(10), 848 new NoOpREHandler()); 849 shouldThrow(); 850 } catch (IllegalArgumentException success) {} 851 } 852 853 /** 854 * Constructor throws if workQueue is set to null 855 */ 856 public void testConstructorNullPointerException4() { 857 try { 858 new ThreadPoolExecutor(1, 2, 859 LONG_DELAY_MS, MILLISECONDS, 860 (BlockingQueue) null, 861 new NoOpREHandler()); 862 shouldThrow(); 863 } catch (NullPointerException success) {} 864 } 865 866 /** 867 * Constructor throws if handler is set to null 868 */ 869 public void testConstructorNullPointerException5() { 870 try { 871 new ThreadPoolExecutor(1, 2, 872 LONG_DELAY_MS, MILLISECONDS, 873 new ArrayBlockingQueue<Runnable>(10), 874 (RejectedExecutionHandler) null); 875 shouldThrow(); 876 } catch (NullPointerException success) {} 877 } 878 879 /** 880 * Constructor throws if corePoolSize argument is less than zero 881 */ 882 public void testConstructor16() { 883 try { 884 new ThreadPoolExecutor(-1, 1, 885 LONG_DELAY_MS, MILLISECONDS, 886 new ArrayBlockingQueue<Runnable>(10), 887 new SimpleThreadFactory(), 888 new NoOpREHandler()); 889 shouldThrow(); 890 } catch (IllegalArgumentException success) {} 891 } 892 893 /** 894 * Constructor throws if maximumPoolSize is less than zero 895 */ 896 public void testConstructor17() { 897 try { 898 new ThreadPoolExecutor(1, -1, 899 LONG_DELAY_MS, MILLISECONDS, 900 new ArrayBlockingQueue<Runnable>(10), 901 new SimpleThreadFactory(), 902 new NoOpREHandler()); 903 shouldThrow(); 904 } catch (IllegalArgumentException success) {} 905 } 906 907 /** 908 * Constructor throws if maximumPoolSize is equal to zero 909 */ 910 public void testConstructor18() { 911 try { 912 new ThreadPoolExecutor(1, 0, 913 LONG_DELAY_MS, MILLISECONDS, 914 new ArrayBlockingQueue<Runnable>(10), 915 new SimpleThreadFactory(), 916 new NoOpREHandler()); 917 shouldThrow(); 918 } catch (IllegalArgumentException success) {} 919 } 920 921 /** 922 * Constructor throws if keepAliveTime is less than zero 923 */ 924 public void testConstructor19() { 925 try { 926 new ThreadPoolExecutor(1, 2, 927 -1L, MILLISECONDS, 928 new ArrayBlockingQueue<Runnable>(10), 929 new SimpleThreadFactory(), 930 new NoOpREHandler()); 931 shouldThrow(); 932 } catch (IllegalArgumentException success) {} 933 } 934 935 /** 936 * Constructor throws if corePoolSize is greater than the maximumPoolSize 937 */ 938 public void testConstructor20() { 939 try { 940 new ThreadPoolExecutor(2, 1, 941 LONG_DELAY_MS, MILLISECONDS, 942 new ArrayBlockingQueue<Runnable>(10), 943 new SimpleThreadFactory(), 944 new NoOpREHandler()); 945 shouldThrow(); 946 } catch (IllegalArgumentException success) {} 947 } 948 949 /** 950 * Constructor throws if workQueue is null 951 */ 952 public void testConstructorNullPointerException6() { 953 try { 954 new ThreadPoolExecutor(1, 2, 955 LONG_DELAY_MS, MILLISECONDS, 956 (BlockingQueue) null, 957 new SimpleThreadFactory(), 958 new NoOpREHandler()); 959 shouldThrow(); 960 } catch (NullPointerException success) {} 961 } 962 963 /** 964 * Constructor throws if handler is null 965 */ 966 public void testConstructorNullPointerException7() { 967 try { 968 new ThreadPoolExecutor(1, 2, 969 LONG_DELAY_MS, MILLISECONDS, 970 new ArrayBlockingQueue<Runnable>(10), 971 new SimpleThreadFactory(), 972 (RejectedExecutionHandler) null); 973 shouldThrow(); 974 } catch (NullPointerException success) {} 975 } 976 977 /** 978 * Constructor throws if ThreadFactory is null 979 */ 980 public void testConstructorNullPointerException8() { 981 try { 982 new ThreadPoolExecutor(1, 2, 983 LONG_DELAY_MS, MILLISECONDS, 984 new ArrayBlockingQueue<Runnable>(10), 985 (ThreadFactory) null, 986 new NoOpREHandler()); 987 shouldThrow(); 988 } catch (NullPointerException success) {} 989 } 990 991 /** 992 * get of submitted callable throws InterruptedException if interrupted 993 */ 994 public void testInterruptedSubmit() throws InterruptedException { 995 final ThreadPoolExecutor p = 996 new ThreadPoolExecutor(1, 1, 997 60, TimeUnit.SECONDS, 998 new ArrayBlockingQueue<Runnable>(10)); 999 1000 final CountDownLatch threadStarted = new CountDownLatch(1); 1001 final CountDownLatch done = new CountDownLatch(1); 1002 try { 1003 Thread t = newStartedThread(new CheckedInterruptedRunnable() { 1004 public void realRun() throws Exception { 1005 Callable task = new CheckedCallable<Boolean>() { 1006 public Boolean realCall() throws InterruptedException { 1007 threadStarted.countDown(); 1008 done.await(); 1009 return Boolean.TRUE; 1010 }}; 1011 p.submit(task).get(); 1012 }}); 1013 1014 assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS)); 1015 t.interrupt(); 1016 awaitTermination(t, MEDIUM_DELAY_MS); 1017 } finally { 1018 done.countDown(); 1019 joinPool(p); 1020 } 1021 } 1022 1023 /** 1024 * execute throws RejectedExecutionException if saturated. 1025 */ 1026 public void testSaturatedExecute() { 1027 ThreadPoolExecutor p = 1028 new ThreadPoolExecutor(1, 1, 1029 LONG_DELAY_MS, MILLISECONDS, 1030 new ArrayBlockingQueue<Runnable>(1)); 1031 final CountDownLatch done = new CountDownLatch(1); 1032 try { 1033 Runnable task = new CheckedRunnable() { 1034 public void realRun() throws InterruptedException { 1035 done.await(); 1036 }}; 1037 for (int i = 0; i < 2; ++i) 1038 p.execute(task); 1039 for (int i = 0; i < 2; ++i) { 1040 try { 1041 p.execute(task); 1042 shouldThrow(); 1043 } catch (RejectedExecutionException success) {} 1044 assertTrue(p.getTaskCount() <= 2); 1045 } 1046 } finally { 1047 done.countDown(); 1048 joinPool(p); 1049 } 1050 } 1051 1052 /** 1053 * submit(runnable) throws RejectedExecutionException if saturated. 1054 */ 1055 public void testSaturatedSubmitRunnable() { 1056 ThreadPoolExecutor p = 1057 new ThreadPoolExecutor(1, 1, 1058 LONG_DELAY_MS, MILLISECONDS, 1059 new ArrayBlockingQueue<Runnable>(1)); 1060 final CountDownLatch done = new CountDownLatch(1); 1061 try { 1062 Runnable task = new CheckedRunnable() { 1063 public void realRun() throws InterruptedException { 1064 done.await(); 1065 }}; 1066 for (int i = 0; i < 2; ++i) 1067 p.submit(task); 1068 for (int i = 0; i < 2; ++i) { 1069 try { 1070 p.execute(task); 1071 shouldThrow(); 1072 } catch (RejectedExecutionException success) {} 1073 assertTrue(p.getTaskCount() <= 2); 1074 } 1075 } finally { 1076 done.countDown(); 1077 joinPool(p); 1078 } 1079 } 1080 1081 /** 1082 * submit(callable) throws RejectedExecutionException if saturated. 1083 */ 1084 public void testSaturatedSubmitCallable() { 1085 ThreadPoolExecutor p = 1086 new ThreadPoolExecutor(1, 1, 1087 LONG_DELAY_MS, MILLISECONDS, 1088 new ArrayBlockingQueue<Runnable>(1)); 1089 final CountDownLatch done = new CountDownLatch(1); 1090 try { 1091 Runnable task = new CheckedRunnable() { 1092 public void realRun() throws InterruptedException { 1093 done.await(); 1094 }}; 1095 for (int i = 0; i < 2; ++i) 1096 p.submit(Executors.callable(task)); 1097 for (int i = 0; i < 2; ++i) { 1098 try { 1099 p.execute(task); 1100 shouldThrow(); 1101 } catch (RejectedExecutionException success) {} 1102 assertTrue(p.getTaskCount() <= 2); 1103 } 1104 } finally { 1105 done.countDown(); 1106 joinPool(p); 1107 } 1108 } 1109 1110 /** 1111 * executor using CallerRunsPolicy runs task if saturated. 1112 */ 1113 public void testSaturatedExecute2() { 1114 RejectedExecutionHandler h = new ThreadPoolExecutor.CallerRunsPolicy(); 1115 final ThreadPoolExecutor p = 1116 new ThreadPoolExecutor(1, 1, 1117 LONG_DELAY_MS, 1118 MILLISECONDS, 1119 new ArrayBlockingQueue<Runnable>(1), 1120 h); 1121 try { 1122 TrackedNoOpRunnable[] tasks = new TrackedNoOpRunnable[5]; 1123 for (int i = 0; i < tasks.length; ++i) 1124 tasks[i] = new TrackedNoOpRunnable(); 1125 TrackedLongRunnable mr = new TrackedLongRunnable(); 1126 p.execute(mr); 1127 for (int i = 0; i < tasks.length; ++i) 1128 p.execute(tasks[i]); 1129 for (int i = 1; i < tasks.length; ++i) 1130 assertTrue(tasks[i].done); 1131 try { p.shutdownNow(); } catch (SecurityException ok) { return; } 1132 } finally { 1133 joinPool(p); 1134 } 1135 } 1136 1137 /** 1138 * executor using DiscardPolicy drops task if saturated. 1139 */ 1140 public void testSaturatedExecute3() { 1141 RejectedExecutionHandler h = new ThreadPoolExecutor.DiscardPolicy(); 1142 final ThreadPoolExecutor p = 1143 new ThreadPoolExecutor(1, 1, 1144 LONG_DELAY_MS, MILLISECONDS, 1145 new ArrayBlockingQueue<Runnable>(1), 1146 h); 1147 try { 1148 TrackedNoOpRunnable[] tasks = new TrackedNoOpRunnable[5]; 1149 for (int i = 0; i < tasks.length; ++i) 1150 tasks[i] = new TrackedNoOpRunnable(); 1151 p.execute(new TrackedLongRunnable()); 1152 for (TrackedNoOpRunnable task : tasks) 1153 p.execute(task); 1154 for (TrackedNoOpRunnable task : tasks) 1155 assertFalse(task.done); 1156 try { p.shutdownNow(); } catch (SecurityException ok) { return; } 1157 } finally { 1158 joinPool(p); 1159 } 1160 } 1161 1162 /** 1163 * executor using DiscardOldestPolicy drops oldest task if saturated. 1164 */ 1165 public void testSaturatedExecute4() { 1166 RejectedExecutionHandler h = new ThreadPoolExecutor.DiscardOldestPolicy(); 1167 final ThreadPoolExecutor p = 1168 new ThreadPoolExecutor(1, 1, 1169 LONG_DELAY_MS, MILLISECONDS, 1170 new ArrayBlockingQueue<Runnable>(1), 1171 h); 1172 try { 1173 p.execute(new TrackedLongRunnable()); 1174 TrackedLongRunnable r2 = new TrackedLongRunnable(); 1175 p.execute(r2); 1176 assertTrue(p.getQueue().contains(r2)); 1177 TrackedNoOpRunnable r3 = new TrackedNoOpRunnable(); 1178 p.execute(r3); 1179 assertFalse(p.getQueue().contains(r2)); 1180 assertTrue(p.getQueue().contains(r3)); 1181 try { p.shutdownNow(); } catch (SecurityException ok) { return; } 1182 } finally { 1183 joinPool(p); 1184 } 1185 } 1186 1187 /** 1188 * execute throws RejectedExecutionException if shutdown 1189 */ 1190 public void testRejectedExecutionExceptionOnShutdown() { 1191 ThreadPoolExecutor p = 1192 new ThreadPoolExecutor(1, 1, 1193 LONG_DELAY_MS, MILLISECONDS, 1194 new ArrayBlockingQueue<Runnable>(1)); 1195 try { p.shutdown(); } catch (SecurityException ok) { return; } 1196 try { 1197 p.execute(new NoOpRunnable()); 1198 shouldThrow(); 1199 } catch (RejectedExecutionException success) {} 1200 1201 joinPool(p); 1202 } 1203 1204 /** 1205 * execute using CallerRunsPolicy drops task on shutdown 1206 */ 1207 public void testCallerRunsOnShutdown() { 1208 RejectedExecutionHandler h = new ThreadPoolExecutor.CallerRunsPolicy(); 1209 final ThreadPoolExecutor p = 1210 new ThreadPoolExecutor(1, 1, 1211 LONG_DELAY_MS, MILLISECONDS, 1212 new ArrayBlockingQueue<Runnable>(1), h); 1213 1214 try { p.shutdown(); } catch (SecurityException ok) { return; } 1215 try { 1216 TrackedNoOpRunnable r = new TrackedNoOpRunnable(); 1217 p.execute(r); 1218 assertFalse(r.done); 1219 } finally { 1220 joinPool(p); 1221 } 1222 } 1223 1224 /** 1225 * execute using DiscardPolicy drops task on shutdown 1226 */ 1227 public void testDiscardOnShutdown() { 1228 RejectedExecutionHandler h = new ThreadPoolExecutor.DiscardPolicy(); 1229 ThreadPoolExecutor p = 1230 new ThreadPoolExecutor(1, 1, 1231 LONG_DELAY_MS, MILLISECONDS, 1232 new ArrayBlockingQueue<Runnable>(1), 1233 h); 1234 1235 try { p.shutdown(); } catch (SecurityException ok) { return; } 1236 try { 1237 TrackedNoOpRunnable r = new TrackedNoOpRunnable(); 1238 p.execute(r); 1239 assertFalse(r.done); 1240 } finally { 1241 joinPool(p); 1242 } 1243 } 1244 1245 /** 1246 * execute using DiscardOldestPolicy drops task on shutdown 1247 */ 1248 public void testDiscardOldestOnShutdown() { 1249 RejectedExecutionHandler h = new ThreadPoolExecutor.DiscardOldestPolicy(); 1250 ThreadPoolExecutor p = 1251 new ThreadPoolExecutor(1, 1, 1252 LONG_DELAY_MS, MILLISECONDS, 1253 new ArrayBlockingQueue<Runnable>(1), 1254 h); 1255 1256 try { p.shutdown(); } catch (SecurityException ok) { return; } 1257 try { 1258 TrackedNoOpRunnable r = new TrackedNoOpRunnable(); 1259 p.execute(r); 1260 assertFalse(r.done); 1261 } finally { 1262 joinPool(p); 1263 } 1264 } 1265 1266 /** 1267 * execute(null) throws NPE 1268 */ 1269 public void testExecuteNull() { 1270 ThreadPoolExecutor p = 1271 new ThreadPoolExecutor(1, 2, 1272 LONG_DELAY_MS, MILLISECONDS, 1273 new ArrayBlockingQueue<Runnable>(10)); 1274 try { 1275 p.execute(null); 1276 shouldThrow(); 1277 } catch (NullPointerException success) {} 1278 1279 joinPool(p); 1280 } 1281 1282 /** 1283 * setCorePoolSize of negative value throws IllegalArgumentException 1284 */ 1285 public void testCorePoolSizeIllegalArgumentException() { 1286 ThreadPoolExecutor p = 1287 new ThreadPoolExecutor(1, 2, 1288 LONG_DELAY_MS, MILLISECONDS, 1289 new ArrayBlockingQueue<Runnable>(10)); 1290 try { 1291 p.setCorePoolSize(-1); 1292 shouldThrow(); 1293 } catch (IllegalArgumentException success) { 1294 } finally { 1295 try { p.shutdown(); } catch (SecurityException ok) { return; } 1296 } 1297 joinPool(p); 1298 } 1299 1300 /** 1301 * setMaximumPoolSize(int) throws IllegalArgumentException if 1302 * given a value less the core pool size 1303 */ 1304 public void testMaximumPoolSizeIllegalArgumentException() { 1305 ThreadPoolExecutor p = 1306 new ThreadPoolExecutor(2, 3, 1307 LONG_DELAY_MS, MILLISECONDS, 1308 new ArrayBlockingQueue<Runnable>(10)); 1309 try { 1310 p.setMaximumPoolSize(1); 1311 shouldThrow(); 1312 } catch (IllegalArgumentException success) { 1313 } finally { 1314 try { p.shutdown(); } catch (SecurityException ok) { return; } 1315 } 1316 joinPool(p); 1317 } 1318 1319 /** 1320 * setMaximumPoolSize throws IllegalArgumentException 1321 * if given a negative value 1322 */ 1323 public void testMaximumPoolSizeIllegalArgumentException2() { 1324 ThreadPoolExecutor p = 1325 new ThreadPoolExecutor(2, 3, 1326 LONG_DELAY_MS, MILLISECONDS, 1327 new ArrayBlockingQueue<Runnable>(10)); 1328 try { 1329 p.setMaximumPoolSize(-1); 1330 shouldThrow(); 1331 } catch (IllegalArgumentException success) { 1332 } finally { 1333 try { p.shutdown(); } catch (SecurityException ok) { return; } 1334 } 1335 joinPool(p); 1336 } 1337 1338 /** 1339 * setKeepAliveTime throws IllegalArgumentException 1340 * when given a negative value 1341 */ 1342 public void testKeepAliveTimeIllegalArgumentException() { 1343 ThreadPoolExecutor p = 1344 new ThreadPoolExecutor(2, 3, 1345 LONG_DELAY_MS, MILLISECONDS, 1346 new ArrayBlockingQueue<Runnable>(10)); 1347 try { 1348 p.setKeepAliveTime(-1,MILLISECONDS); 1349 shouldThrow(); 1350 } catch (IllegalArgumentException success) { 1351 } finally { 1352 try { p.shutdown(); } catch (SecurityException ok) { return; } 1353 } 1354 joinPool(p); 1355 } 1356 1357 /** 1358 * terminated() is called on termination 1359 */ 1360 public void testTerminated() { 1361 ExtendedTPE p = new ExtendedTPE(); 1362 try { p.shutdown(); } catch (SecurityException ok) { return; } 1363 assertTrue(p.terminatedCalled()); 1364 joinPool(p); 1365 } 1366 1367 /** 1368 * beforeExecute and afterExecute are called when executing task 1369 */ 1370 public void testBeforeAfter() throws InterruptedException { 1371 ExtendedTPE p = new ExtendedTPE(); 1372 try { 1373 final CountDownLatch done = new CountDownLatch(1); 1374 final CheckedRunnable task = new CheckedRunnable() { 1375 public void realRun() { 1376 done.countDown(); 1377 }}; 1378 p.execute(task); 1379 await(p.afterCalled); 1380 assertEquals(0, done.getCount()); 1381 assertTrue(p.afterCalled()); 1382 assertTrue(p.beforeCalled()); 1383 try { p.shutdown(); } catch (SecurityException ok) { return; } 1384 } finally { 1385 joinPool(p); 1386 } 1387 } 1388 1389 /** 1390 * completed submit of callable returns result 1391 */ 1392 public void testSubmitCallable() throws Exception { 1393 ExecutorService e = 1394 new ThreadPoolExecutor(2, 2, 1395 LONG_DELAY_MS, MILLISECONDS, 1396 new ArrayBlockingQueue<Runnable>(10)); 1397 try { 1398 Future<String> future = e.submit(new StringTask()); 1399 String result = future.get(); 1400 assertSame(TEST_STRING, result); 1401 } finally { 1402 joinPool(e); 1403 } 1404 } 1405 1406 /** 1407 * completed submit of runnable returns successfully 1408 */ 1409 public void testSubmitRunnable() throws Exception { 1410 ExecutorService e = 1411 new ThreadPoolExecutor(2, 2, 1412 LONG_DELAY_MS, MILLISECONDS, 1413 new ArrayBlockingQueue<Runnable>(10)); 1414 try { 1415 Future<?> future = e.submit(new NoOpRunnable()); 1416 future.get(); 1417 assertTrue(future.isDone()); 1418 } finally { 1419 joinPool(e); 1420 } 1421 } 1422 1423 /** 1424 * completed submit of (runnable, result) returns result 1425 */ 1426 public void testSubmitRunnable2() throws Exception { 1427 ExecutorService e = 1428 new ThreadPoolExecutor(2, 2, 1429 LONG_DELAY_MS, MILLISECONDS, 1430 new ArrayBlockingQueue<Runnable>(10)); 1431 try { 1432 Future<String> future = e.submit(new NoOpRunnable(), TEST_STRING); 1433 String result = future.get(); 1434 assertSame(TEST_STRING, result); 1435 } finally { 1436 joinPool(e); 1437 } 1438 } 1439 1440 /** 1441 * invokeAny(null) throws NPE 1442 */ 1443 public void testInvokeAny1() throws Exception { 1444 ExecutorService e = 1445 new ThreadPoolExecutor(2, 2, 1446 LONG_DELAY_MS, MILLISECONDS, 1447 new ArrayBlockingQueue<Runnable>(10)); 1448 try { 1449 e.invokeAny(null); 1450 shouldThrow(); 1451 } catch (NullPointerException success) { 1452 } finally { 1453 joinPool(e); 1454 } 1455 } 1456 1457 /** 1458 * invokeAny(empty collection) throws IAE 1459 */ 1460 public void testInvokeAny2() throws Exception { 1461 ExecutorService e = 1462 new ThreadPoolExecutor(2, 2, 1463 LONG_DELAY_MS, MILLISECONDS, 1464 new ArrayBlockingQueue<Runnable>(10)); 1465 try { 1466 e.invokeAny(new ArrayList<Callable<String>>()); 1467 shouldThrow(); 1468 } catch (IllegalArgumentException success) { 1469 } finally { 1470 joinPool(e); 1471 } 1472 } 1473 1474 /** 1475 * invokeAny(c) throws NPE if c has null elements 1476 */ 1477 public void testInvokeAny3() throws Exception { 1478 final CountDownLatch latch = new CountDownLatch(1); 1479 final ExecutorService e = 1480 new ThreadPoolExecutor(2, 2, 1481 LONG_DELAY_MS, MILLISECONDS, 1482 new ArrayBlockingQueue<Runnable>(10)); 1483 List<Callable<String>> l = new ArrayList<Callable<String>>(); 1484 l.add(latchAwaitingStringTask(latch)); 1485 l.add(null); 1486 try { 1487 e.invokeAny(l); 1488 shouldThrow(); 1489 } catch (NullPointerException success) { 1490 } finally { 1491 latch.countDown(); 1492 joinPool(e); 1493 } 1494 } 1495 1496 /** 1497 * invokeAny(c) throws ExecutionException if no task completes 1498 */ 1499 public void testInvokeAny4() throws Exception { 1500 ExecutorService e = 1501 new ThreadPoolExecutor(2, 2, 1502 LONG_DELAY_MS, MILLISECONDS, 1503 new ArrayBlockingQueue<Runnable>(10)); 1504 List<Callable<String>> l = new ArrayList<Callable<String>>(); 1505 l.add(new NPETask()); 1506 try { 1507 e.invokeAny(l); 1508 shouldThrow(); 1509 } catch (ExecutionException success) { 1510 assertTrue(success.getCause() instanceof NullPointerException); 1511 } finally { 1512 joinPool(e); 1513 } 1514 } 1515 1516 /** 1517 * invokeAny(c) returns result of some task 1518 */ 1519 public void testInvokeAny5() throws Exception { 1520 ExecutorService e = 1521 new ThreadPoolExecutor(2, 2, 1522 LONG_DELAY_MS, MILLISECONDS, 1523 new ArrayBlockingQueue<Runnable>(10)); 1524 try { 1525 List<Callable<String>> l = new ArrayList<Callable<String>>(); 1526 l.add(new StringTask()); 1527 l.add(new StringTask()); 1528 String result = e.invokeAny(l); 1529 assertSame(TEST_STRING, result); 1530 } finally { 1531 joinPool(e); 1532 } 1533 } 1534 1535 /** 1536 * invokeAll(null) throws NPE 1537 */ 1538 public void testInvokeAll1() throws Exception { 1539 ExecutorService e = 1540 new ThreadPoolExecutor(2, 2, 1541 LONG_DELAY_MS, MILLISECONDS, 1542 new ArrayBlockingQueue<Runnable>(10)); 1543 try { 1544 e.invokeAll(null); 1545 shouldThrow(); 1546 } catch (NullPointerException success) { 1547 } finally { 1548 joinPool(e); 1549 } 1550 } 1551 1552 /** 1553 * invokeAll(empty collection) returns empty collection 1554 */ 1555 public void testInvokeAll2() throws InterruptedException { 1556 ExecutorService e = 1557 new ThreadPoolExecutor(2, 2, 1558 LONG_DELAY_MS, MILLISECONDS, 1559 new ArrayBlockingQueue<Runnable>(10)); 1560 try { 1561 List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>()); 1562 assertTrue(r.isEmpty()); 1563 } finally { 1564 joinPool(e); 1565 } 1566 } 1567 1568 /** 1569 * invokeAll(c) throws NPE if c has null elements 1570 */ 1571 public void testInvokeAll3() throws Exception { 1572 ExecutorService e = 1573 new ThreadPoolExecutor(2, 2, 1574 LONG_DELAY_MS, MILLISECONDS, 1575 new ArrayBlockingQueue<Runnable>(10)); 1576 List<Callable<String>> l = new ArrayList<Callable<String>>(); 1577 l.add(new StringTask()); 1578 l.add(null); 1579 try { 1580 e.invokeAll(l); 1581 shouldThrow(); 1582 } catch (NullPointerException success) { 1583 } finally { 1584 joinPool(e); 1585 } 1586 } 1587 1588 /** 1589 * get of element of invokeAll(c) throws exception on failed task 1590 */ 1591 public void testInvokeAll4() throws Exception { 1592 ExecutorService e = 1593 new ThreadPoolExecutor(2, 2, 1594 LONG_DELAY_MS, MILLISECONDS, 1595 new ArrayBlockingQueue<Runnable>(10)); 1596 try { 1597 List<Callable<String>> l = new ArrayList<Callable<String>>(); 1598 l.add(new NPETask()); 1599 List<Future<String>> futures = e.invokeAll(l); 1600 assertEquals(1, futures.size()); 1601 try { 1602 futures.get(0).get(); 1603 shouldThrow(); 1604 } catch (ExecutionException success) { 1605 assertTrue(success.getCause() instanceof NullPointerException); 1606 } 1607 } finally { 1608 joinPool(e); 1609 } 1610 } 1611 1612 /** 1613 * invokeAll(c) returns results of all completed tasks 1614 */ 1615 public void testInvokeAll5() throws Exception { 1616 ExecutorService e = 1617 new ThreadPoolExecutor(2, 2, 1618 LONG_DELAY_MS, MILLISECONDS, 1619 new ArrayBlockingQueue<Runnable>(10)); 1620 try { 1621 List<Callable<String>> l = new ArrayList<Callable<String>>(); 1622 l.add(new StringTask()); 1623 l.add(new StringTask()); 1624 List<Future<String>> futures = e.invokeAll(l); 1625 assertEquals(2, futures.size()); 1626 for (Future<String> future : futures) 1627 assertSame(TEST_STRING, future.get()); 1628 } finally { 1629 joinPool(e); 1630 } 1631 } 1632 1633 /** 1634 * timed invokeAny(null) throws NPE 1635 */ 1636 public void testTimedInvokeAny1() throws Exception { 1637 ExecutorService e = 1638 new ThreadPoolExecutor(2, 2, 1639 LONG_DELAY_MS, MILLISECONDS, 1640 new ArrayBlockingQueue<Runnable>(10)); 1641 try { 1642 e.invokeAny(null, MEDIUM_DELAY_MS, MILLISECONDS); 1643 shouldThrow(); 1644 } catch (NullPointerException success) { 1645 } finally { 1646 joinPool(e); 1647 } 1648 } 1649 1650 /** 1651 * timed invokeAny(,,null) throws NPE 1652 */ 1653 public void testTimedInvokeAnyNullTimeUnit() throws Exception { 1654 ExecutorService e = 1655 new ThreadPoolExecutor(2, 2, 1656 LONG_DELAY_MS, MILLISECONDS, 1657 new ArrayBlockingQueue<Runnable>(10)); 1658 List<Callable<String>> l = new ArrayList<Callable<String>>(); 1659 l.add(new StringTask()); 1660 try { 1661 e.invokeAny(l, MEDIUM_DELAY_MS, null); 1662 shouldThrow(); 1663 } catch (NullPointerException success) { 1664 } finally { 1665 joinPool(e); 1666 } 1667 } 1668 1669 /** 1670 * timed invokeAny(empty collection) throws IAE 1671 */ 1672 public void testTimedInvokeAny2() throws Exception { 1673 ExecutorService e = 1674 new ThreadPoolExecutor(2, 2, 1675 LONG_DELAY_MS, MILLISECONDS, 1676 new ArrayBlockingQueue<Runnable>(10)); 1677 try { 1678 e.invokeAny(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, MILLISECONDS); 1679 shouldThrow(); 1680 } catch (IllegalArgumentException success) { 1681 } finally { 1682 joinPool(e); 1683 } 1684 } 1685 1686 /** 1687 * timed invokeAny(c) throws NPE if c has null elements 1688 */ 1689 public void testTimedInvokeAny3() throws Exception { 1690 final CountDownLatch latch = new CountDownLatch(1); 1691 final ExecutorService e = 1692 new ThreadPoolExecutor(2, 2, 1693 LONG_DELAY_MS, MILLISECONDS, 1694 new ArrayBlockingQueue<Runnable>(10)); 1695 List<Callable<String>> l = new ArrayList<Callable<String>>(); 1696 l.add(latchAwaitingStringTask(latch)); 1697 l.add(null); 1698 try { 1699 e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS); 1700 shouldThrow(); 1701 } catch (NullPointerException success) { 1702 } finally { 1703 latch.countDown(); 1704 joinPool(e); 1705 } 1706 } 1707 1708 /** 1709 * timed invokeAny(c) throws ExecutionException if no task completes 1710 */ 1711 public void testTimedInvokeAny4() throws Exception { 1712 ExecutorService e = 1713 new ThreadPoolExecutor(2, 2, 1714 LONG_DELAY_MS, MILLISECONDS, 1715 new ArrayBlockingQueue<Runnable>(10)); 1716 List<Callable<String>> l = new ArrayList<Callable<String>>(); 1717 l.add(new NPETask()); 1718 try { 1719 e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS); 1720 shouldThrow(); 1721 } catch (ExecutionException success) { 1722 assertTrue(success.getCause() instanceof NullPointerException); 1723 } finally { 1724 joinPool(e); 1725 } 1726 } 1727 1728 /** 1729 * timed invokeAny(c) returns result of some task 1730 */ 1731 public void testTimedInvokeAny5() throws Exception { 1732 ExecutorService e = 1733 new ThreadPoolExecutor(2, 2, 1734 LONG_DELAY_MS, MILLISECONDS, 1735 new ArrayBlockingQueue<Runnable>(10)); 1736 try { 1737 List<Callable<String>> l = new ArrayList<Callable<String>>(); 1738 l.add(new StringTask()); 1739 l.add(new StringTask()); 1740 String result = e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS); 1741 assertSame(TEST_STRING, result); 1742 } finally { 1743 joinPool(e); 1744 } 1745 } 1746 1747 /** 1748 * timed invokeAll(null) throws NPE 1749 */ 1750 public void testTimedInvokeAll1() throws Exception { 1751 ExecutorService e = 1752 new ThreadPoolExecutor(2, 2, 1753 LONG_DELAY_MS, MILLISECONDS, 1754 new ArrayBlockingQueue<Runnable>(10)); 1755 try { 1756 e.invokeAll(null, MEDIUM_DELAY_MS, MILLISECONDS); 1757 shouldThrow(); 1758 } catch (NullPointerException success) { 1759 } finally { 1760 joinPool(e); 1761 } 1762 } 1763 1764 /** 1765 * timed invokeAll(,,null) throws NPE 1766 */ 1767 public void testTimedInvokeAllNullTimeUnit() throws Exception { 1768 ExecutorService e = 1769 new ThreadPoolExecutor(2, 2, 1770 LONG_DELAY_MS, MILLISECONDS, 1771 new ArrayBlockingQueue<Runnable>(10)); 1772 List<Callable<String>> l = new ArrayList<Callable<String>>(); 1773 l.add(new StringTask()); 1774 try { 1775 e.invokeAll(l, MEDIUM_DELAY_MS, null); 1776 shouldThrow(); 1777 } catch (NullPointerException success) { 1778 } finally { 1779 joinPool(e); 1780 } 1781 } 1782 1783 /** 1784 * timed invokeAll(empty collection) returns empty collection 1785 */ 1786 public void testTimedInvokeAll2() throws InterruptedException { 1787 ExecutorService e = 1788 new ThreadPoolExecutor(2, 2, 1789 LONG_DELAY_MS, MILLISECONDS, 1790 new ArrayBlockingQueue<Runnable>(10)); 1791 try { 1792 List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, MILLISECONDS); 1793 assertTrue(r.isEmpty()); 1794 } finally { 1795 joinPool(e); 1796 } 1797 } 1798 1799 /** 1800 * timed invokeAll(c) throws NPE if c has null elements 1801 */ 1802 public void testTimedInvokeAll3() throws Exception { 1803 ExecutorService e = 1804 new ThreadPoolExecutor(2, 2, 1805 LONG_DELAY_MS, MILLISECONDS, 1806 new ArrayBlockingQueue<Runnable>(10)); 1807 List<Callable<String>> l = new ArrayList<Callable<String>>(); 1808 l.add(new StringTask()); 1809 l.add(null); 1810 try { 1811 e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS); 1812 shouldThrow(); 1813 } catch (NullPointerException success) { 1814 } finally { 1815 joinPool(e); 1816 } 1817 } 1818 1819 /** 1820 * get of element of invokeAll(c) throws exception on failed task 1821 */ 1822 public void testTimedInvokeAll4() throws Exception { 1823 ExecutorService e = 1824 new ThreadPoolExecutor(2, 2, 1825 LONG_DELAY_MS, MILLISECONDS, 1826 new ArrayBlockingQueue<Runnable>(10)); 1827 List<Callable<String>> l = new ArrayList<Callable<String>>(); 1828 l.add(new NPETask()); 1829 List<Future<String>> futures = 1830 e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS); 1831 assertEquals(1, futures.size()); 1832 try { 1833 futures.get(0).get(); 1834 shouldThrow(); 1835 } catch (ExecutionException success) { 1836 assertTrue(success.getCause() instanceof NullPointerException); 1837 } finally { 1838 joinPool(e); 1839 } 1840 } 1841 1842 /** 1843 * timed invokeAll(c) returns results of all completed tasks 1844 */ 1845 public void testTimedInvokeAll5() throws Exception { 1846 ExecutorService e = 1847 new ThreadPoolExecutor(2, 2, 1848 LONG_DELAY_MS, MILLISECONDS, 1849 new ArrayBlockingQueue<Runnable>(10)); 1850 try { 1851 List<Callable<String>> l = new ArrayList<Callable<String>>(); 1852 l.add(new StringTask()); 1853 l.add(new StringTask()); 1854 List<Future<String>> futures = 1855 e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS); 1856 assertEquals(2, futures.size()); 1857 for (Future<String> future : futures) 1858 assertSame(TEST_STRING, future.get()); 1859 } finally { 1860 joinPool(e); 1861 } 1862 } 1863 1864 /** 1865 * timed invokeAll(c) cancels tasks not completed by timeout 1866 */ 1867 public void testTimedInvokeAll6() throws Exception { 1868 ExecutorService e = 1869 new ThreadPoolExecutor(2, 2, 1870 LONG_DELAY_MS, MILLISECONDS, 1871 new ArrayBlockingQueue<Runnable>(10)); 1872 try { 1873 List<Callable<String>> l = new ArrayList<Callable<String>>(); 1874 l.add(new StringTask()); 1875 l.add(Executors.callable(new MediumPossiblyInterruptedRunnable(), TEST_STRING)); 1876 l.add(new StringTask()); 1877 List<Future<String>> futures = 1878 e.invokeAll(l, SHORT_DELAY_MS, MILLISECONDS); 1879 assertEquals(l.size(), futures.size()); 1880 for (Future future : futures) 1881 assertTrue(future.isDone()); 1882 assertFalse(futures.get(0).isCancelled()); 1883 assertTrue(futures.get(1).isCancelled()); 1884 } finally { 1885 joinPool(e); 1886 } 1887 } 1888 1889 /** 1890 * Execution continues if there is at least one thread even if 1891 * thread factory fails to create more 1892 */ 1893 public void testFailingThreadFactory() throws InterruptedException { 1894 final ExecutorService e = 1895 new ThreadPoolExecutor(100, 100, 1896 LONG_DELAY_MS, MILLISECONDS, 1897 new LinkedBlockingQueue<Runnable>(), 1898 new FailingThreadFactory()); 1899 try { 1900 final int TASKS = 100; 1901 final CountDownLatch done = new CountDownLatch(TASKS); 1902 for (int k = 0; k < TASKS; ++k) 1903 e.execute(new CheckedRunnable() { 1904 public void realRun() { 1905 done.countDown(); 1906 }}); 1907 assertTrue(done.await(LONG_DELAY_MS, MILLISECONDS)); 1908 } finally { 1909 joinPool(e); 1910 } 1911 } 1912 1913 /** 1914 * allowsCoreThreadTimeOut is by default false. 1915 */ 1916 public void testAllowsCoreThreadTimeOut() { 1917 final ThreadPoolExecutor p = 1918 new ThreadPoolExecutor(2, 2, 1919 1000, MILLISECONDS, 1920 new ArrayBlockingQueue<Runnable>(10)); 1921 assertFalse(p.allowsCoreThreadTimeOut()); 1922 joinPool(p); 1923 } 1924 1925 /** 1926 * allowCoreThreadTimeOut(true) causes idle threads to time out 1927 */ 1928 public void testAllowCoreThreadTimeOut_true() throws Exception { 1929 long coreThreadTimeOut = SHORT_DELAY_MS; 1930 final ThreadPoolExecutor p = 1931 new ThreadPoolExecutor(2, 10, 1932 coreThreadTimeOut, MILLISECONDS, 1933 new ArrayBlockingQueue<Runnable>(10)); 1934 final CountDownLatch threadStarted = new CountDownLatch(1); 1935 try { 1936 p.allowCoreThreadTimeOut(true); 1937 p.execute(new CheckedRunnable() { 1938 public void realRun() { 1939 threadStarted.countDown(); 1940 assertEquals(1, p.getPoolSize()); 1941 }}); 1942 await(threadStarted); 1943 delay(coreThreadTimeOut); 1944 long startTime = System.nanoTime(); 1945 while (p.getPoolSize() > 0 1946 && millisElapsedSince(startTime) < LONG_DELAY_MS) 1947 Thread.yield(); 1948 assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS); 1949 assertEquals(0, p.getPoolSize()); 1950 } finally { 1951 joinPool(p); 1952 } 1953 } 1954 1955 /** 1956 * allowCoreThreadTimeOut(false) causes idle threads not to time out 1957 */ 1958 public void testAllowCoreThreadTimeOut_false() throws Exception { 1959 long coreThreadTimeOut = SHORT_DELAY_MS; 1960 final ThreadPoolExecutor p = 1961 new ThreadPoolExecutor(2, 10, 1962 coreThreadTimeOut, MILLISECONDS, 1963 new ArrayBlockingQueue<Runnable>(10)); 1964 final CountDownLatch threadStarted = new CountDownLatch(1); 1965 try { 1966 p.allowCoreThreadTimeOut(false); 1967 p.execute(new CheckedRunnable() { 1968 public void realRun() throws InterruptedException { 1969 threadStarted.countDown(); 1970 assertTrue(p.getPoolSize() >= 1); 1971 }}); 1972 delay(2 * coreThreadTimeOut); 1973 assertTrue(p.getPoolSize() >= 1); 1974 } finally { 1975 joinPool(p); 1976 } 1977 } 1978 1979 /** 1980 * execute allows the same task to be submitted multiple times, even 1981 * if rejected 1982 */ 1983 public void testRejectedRecycledTask() throws InterruptedException { 1984 final int nTasks = 1000; 1985 final CountDownLatch done = new CountDownLatch(nTasks); 1986 final Runnable recycledTask = new Runnable() { 1987 public void run() { 1988 done.countDown(); 1989 }}; 1990 final ThreadPoolExecutor p = 1991 new ThreadPoolExecutor(1, 30, 60, TimeUnit.SECONDS, 1992 new ArrayBlockingQueue(30)); 1993 try { 1994 for (int i = 0; i < nTasks; ++i) { 1995 for (;;) { 1996 try { 1997 p.execute(recycledTask); 1998 break; 1999 } 2000 catch (RejectedExecutionException ignore) {} 2001 } 2002 } 2003 // enough time to run all tasks 2004 assertTrue(done.await(nTasks * SHORT_DELAY_MS, MILLISECONDS)); 2005 } finally { 2006 joinPool(p); 2007 } 2008 } 2009 2010 } 2011
