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 { |
414 |
|
}}); |
415 |
|
assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS)); |
416 |
|
assertEquals(1, p.getTaskCount()); |
417 |
– |
} finally { |
417 |
|
done.countDown(); |
419 |
– |
joinPool(p); |
418 |
|
} |
419 |
|
} |
420 |
|
|
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 |
|
/** |
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 |
|
/** |
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(); |
488 |
– |
} 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 |
|
} |
491 |
– |
assertTrue(p.awaitTermination(LONG_DELAY_MS, MILLISECONDS)); |
492 |
– |
assertTrue(p.isTerminated()); |
494 |
|
} |
495 |
|
|
496 |
|
/** |
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 { |
514 |
|
assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS)); |
515 |
|
assertFalse(p.isTerminating()); |
516 |
|
done.countDown(); |
516 |
– |
} 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 |
|
} |
519 |
– |
assertTrue(p.awaitTermination(LONG_DELAY_MS, MILLISECONDS)); |
520 |
– |
assertTrue(p.isTerminated()); |
521 |
– |
assertFalse(p.isTerminating()); |
522 |
|
} |
523 |
|
|
524 |
|
/** |
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>() { |
550 |
|
assertFalse(q.contains(tasks[0])); |
551 |
|
assertTrue(q.contains(tasks[tasks.length - 1])); |
552 |
|
assertEquals(tasks.length - 1, q.size()); |
553 |
– |
} finally { |
553 |
|
done.countDown(); |
555 |
– |
joinPool(p); |
554 |
|
} |
555 |
|
} |
556 |
|
|