11 |
|
import java.security.PrivilegedExceptionAction; |
12 |
|
import java.util.ArrayList; |
13 |
|
import java.util.Collection; |
14 |
+ |
import java.util.Collections; |
15 |
|
import java.util.List; |
16 |
|
import java.util.concurrent.Callable; |
17 |
|
import java.util.concurrent.CountDownLatch; |
25 |
|
import java.util.concurrent.RecursiveTask; |
26 |
|
import java.util.concurrent.RejectedExecutionException; |
27 |
|
import java.util.concurrent.atomic.AtomicBoolean; |
28 |
+ |
import java.util.concurrent.atomic.AtomicInteger; |
29 |
|
import java.util.concurrent.locks.ReentrantLock; |
30 |
|
|
29 |
– |
import junit.framework.AssertionFailedError; |
31 |
|
import junit.framework.Test; |
32 |
|
import junit.framework.TestSuite; |
33 |
|
|
58 |
|
|
59 |
|
// Some classes to test extension and factory methods |
60 |
|
|
60 |
– |
static class MyHandler implements Thread.UncaughtExceptionHandler { |
61 |
– |
volatile int catches = 0; |
62 |
– |
public void uncaughtException(Thread t, Throwable e) { |
63 |
– |
++catches; |
64 |
– |
} |
65 |
– |
} |
66 |
– |
|
61 |
|
static class MyError extends Error {} |
62 |
|
|
63 |
|
// to test handlers |
68 |
|
|
69 |
|
static class FailingThreadFactory |
70 |
|
implements ForkJoinPool.ForkJoinWorkerThreadFactory { |
71 |
< |
volatile int calls = 0; |
71 |
> |
final AtomicInteger calls = new AtomicInteger(0); |
72 |
|
public ForkJoinWorkerThread newThread(ForkJoinPool p) { |
73 |
< |
if (++calls > 1) return null; |
73 |
> |
if (calls.incrementAndGet() > 1) return null; |
74 |
|
return new FailingFJWSubclass(p); |
75 |
|
} |
76 |
|
} |
217 |
|
taskStarted.countDown(); |
218 |
|
assertEquals(1, p.getPoolSize()); |
219 |
|
assertEquals(1, p.getActiveThreadCount()); |
220 |
< |
done.await(); |
220 |
> |
await(done); |
221 |
|
}}; |
222 |
|
Future<?> future = p.submit(task); |
223 |
|
await(taskStarted); |
240 |
|
assertFalse(p.awaitTermination(Long.MIN_VALUE, MILLISECONDS)); |
241 |
|
assertFalse(p.awaitTermination(-1L, NANOSECONDS)); |
242 |
|
assertFalse(p.awaitTermination(-1L, MILLISECONDS)); |
243 |
< |
assertFalse(p.awaitTermination(0L, NANOSECONDS)); |
244 |
< |
assertFalse(p.awaitTermination(0L, MILLISECONDS)); |
243 |
> |
assertFalse(p.awaitTermination(randomExpiredTimeout(), |
244 |
> |
randomTimeUnit())); |
245 |
|
long timeoutNanos = 999999L; |
246 |
|
long startTime = System.nanoTime(); |
247 |
|
assertFalse(p.awaitTermination(timeoutNanos, NANOSECONDS)); |
303 |
|
p.getFactory()); |
304 |
|
while (! p.isQuiescent()) { |
305 |
|
if (millisElapsedSince(startTime) > LONG_DELAY_MS) |
306 |
< |
throw new AssertionFailedError("timed out"); |
306 |
> |
throw new AssertionError("timed out"); |
307 |
|
assertFalse(p.getAsyncMode()); |
308 |
|
assertFalse(p.isShutdown()); |
309 |
|
assertFalse(p.isTerminating()); |
422 |
|
done.set(true); |
423 |
|
}}); |
424 |
|
assertNull(future.get()); |
425 |
< |
assertNull(future.get(0, MILLISECONDS)); |
425 |
> |
assertNull(future.get(randomExpiredTimeout(), randomTimeUnit())); |
426 |
|
assertTrue(done.get()); |
427 |
|
assertTrue(future.isDone()); |
428 |
|
assertFalse(future.isCancelled()); |
631 |
|
public void testInvokeAny3() throws Throwable { |
632 |
|
ExecutorService e = new ForkJoinPool(1); |
633 |
|
try (PoolCleaner cleaner = cleaner(e)) { |
634 |
< |
List<Callable<String>> l = new ArrayList<Callable<String>>(); |
634 |
> |
List<Callable<String>> l = new ArrayList<>(); |
635 |
|
l.add(null); |
636 |
|
try { |
637 |
|
e.invokeAny(l); |
647 |
|
CountDownLatch latch = new CountDownLatch(1); |
648 |
|
ExecutorService e = new ForkJoinPool(1); |
649 |
|
try (PoolCleaner cleaner = cleaner(e)) { |
650 |
< |
List<Callable<String>> l = new ArrayList<Callable<String>>(); |
650 |
> |
List<Callable<String>> l = new ArrayList<>(); |
651 |
|
l.add(latchAwaitingStringTask(latch)); |
652 |
|
l.add(null); |
653 |
|
try { |
664 |
|
public void testInvokeAny5() throws Throwable { |
665 |
|
ExecutorService e = new ForkJoinPool(1); |
666 |
|
try (PoolCleaner cleaner = cleaner(e)) { |
667 |
< |
List<Callable<String>> l = new ArrayList<Callable<String>>(); |
667 |
> |
List<Callable<String>> l = new ArrayList<>(); |
668 |
|
l.add(new NPETask()); |
669 |
|
try { |
670 |
|
e.invokeAny(l); |
681 |
|
public void testInvokeAny6() throws Throwable { |
682 |
|
ExecutorService e = new ForkJoinPool(1); |
683 |
|
try (PoolCleaner cleaner = cleaner(e)) { |
684 |
< |
List<Callable<String>> l = new ArrayList<Callable<String>>(); |
684 |
> |
List<Callable<String>> l = new ArrayList<>(); |
685 |
|
l.add(new StringTask()); |
686 |
|
l.add(new StringTask()); |
687 |
|
String result = e.invokeAny(l); |
703 |
|
} |
704 |
|
|
705 |
|
/** |
706 |
< |
* invokeAll(empty collection) returns empty collection |
706 |
> |
* invokeAll(empty collection) returns empty list |
707 |
|
*/ |
708 |
|
public void testInvokeAll2() throws InterruptedException { |
709 |
|
ExecutorService e = new ForkJoinPool(1); |
710 |
+ |
final Collection<Callable<String>> emptyCollection |
711 |
+ |
= Collections.emptyList(); |
712 |
|
try (PoolCleaner cleaner = cleaner(e)) { |
713 |
< |
List<Future<String>> r |
718 |
< |
= e.invokeAll(new ArrayList<Callable<String>>()); |
713 |
> |
List<Future<String>> r = e.invokeAll(emptyCollection); |
714 |
|
assertTrue(r.isEmpty()); |
715 |
|
} |
716 |
|
} |
721 |
|
public void testInvokeAll3() throws InterruptedException { |
722 |
|
ExecutorService e = new ForkJoinPool(1); |
723 |
|
try (PoolCleaner cleaner = cleaner(e)) { |
724 |
< |
List<Callable<String>> l = new ArrayList<Callable<String>>(); |
724 |
> |
List<Callable<String>> l = new ArrayList<>(); |
725 |
|
l.add(new StringTask()); |
726 |
|
l.add(null); |
727 |
|
try { |
738 |
|
public void testInvokeAll4() throws Throwable { |
739 |
|
ExecutorService e = new ForkJoinPool(1); |
740 |
|
try (PoolCleaner cleaner = cleaner(e)) { |
741 |
< |
List<Callable<String>> l = new ArrayList<Callable<String>>(); |
741 |
> |
List<Callable<String>> l = new ArrayList<>(); |
742 |
|
l.add(new NPETask()); |
743 |
|
List<Future<String>> futures = e.invokeAll(l); |
744 |
|
assertEquals(1, futures.size()); |
757 |
|
public void testInvokeAll5() throws Throwable { |
758 |
|
ExecutorService e = new ForkJoinPool(1); |
759 |
|
try (PoolCleaner cleaner = cleaner(e)) { |
760 |
< |
List<Callable<String>> l = new ArrayList<Callable<String>>(); |
760 |
> |
List<Callable<String>> l = new ArrayList<>(); |
761 |
|
l.add(new StringTask()); |
762 |
|
l.add(new StringTask()); |
763 |
|
List<Future<String>> futures = e.invokeAll(l); |
774 |
|
ExecutorService e = new ForkJoinPool(1); |
775 |
|
try (PoolCleaner cleaner = cleaner(e)) { |
776 |
|
try { |
777 |
< |
e.invokeAny(null, MEDIUM_DELAY_MS, MILLISECONDS); |
777 |
> |
e.invokeAny(null, randomTimeout(), randomTimeUnit()); |
778 |
|
shouldThrow(); |
779 |
|
} catch (NullPointerException success) {} |
780 |
|
} |
786 |
|
public void testTimedInvokeAnyNullTimeUnit() throws Throwable { |
787 |
|
ExecutorService e = new ForkJoinPool(1); |
788 |
|
try (PoolCleaner cleaner = cleaner(e)) { |
789 |
< |
List<Callable<String>> l = new ArrayList<Callable<String>>(); |
789 |
> |
List<Callable<String>> l = new ArrayList<>(); |
790 |
|
l.add(new StringTask()); |
791 |
|
try { |
792 |
< |
e.invokeAny(l, MEDIUM_DELAY_MS, null); |
792 |
> |
e.invokeAny(l, randomTimeout(), null); |
793 |
|
shouldThrow(); |
794 |
|
} catch (NullPointerException success) {} |
795 |
|
} |
803 |
|
try (PoolCleaner cleaner = cleaner(e)) { |
804 |
|
try { |
805 |
|
e.invokeAny(new ArrayList<Callable<String>>(), |
806 |
< |
MEDIUM_DELAY_MS, MILLISECONDS); |
806 |
> |
randomTimeout(), randomTimeUnit()); |
807 |
|
shouldThrow(); |
808 |
|
} catch (IllegalArgumentException success) {} |
809 |
|
} |
816 |
|
CountDownLatch latch = new CountDownLatch(1); |
817 |
|
ExecutorService e = new ForkJoinPool(1); |
818 |
|
try (PoolCleaner cleaner = cleaner(e)) { |
819 |
< |
List<Callable<String>> l = new ArrayList<Callable<String>>(); |
819 |
> |
List<Callable<String>> l = new ArrayList<>(); |
820 |
|
l.add(latchAwaitingStringTask(latch)); |
821 |
|
l.add(null); |
822 |
|
try { |
823 |
< |
e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS); |
823 |
> |
e.invokeAny(l, randomTimeout(), randomTimeUnit()); |
824 |
|
shouldThrow(); |
825 |
|
} catch (NullPointerException success) {} |
826 |
|
latch.countDown(); |
834 |
|
ExecutorService e = new ForkJoinPool(1); |
835 |
|
try (PoolCleaner cleaner = cleaner(e)) { |
836 |
|
long startTime = System.nanoTime(); |
837 |
< |
List<Callable<String>> l = new ArrayList<Callable<String>>(); |
837 |
> |
List<Callable<String>> l = new ArrayList<>(); |
838 |
|
l.add(new NPETask()); |
839 |
|
try { |
840 |
|
e.invokeAny(l, LONG_DELAY_MS, MILLISECONDS); |
853 |
|
ExecutorService e = new ForkJoinPool(1); |
854 |
|
try (PoolCleaner cleaner = cleaner(e)) { |
855 |
|
long startTime = System.nanoTime(); |
856 |
< |
List<Callable<String>> l = new ArrayList<Callable<String>>(); |
856 |
> |
List<Callable<String>> l = new ArrayList<>(); |
857 |
|
l.add(new StringTask()); |
858 |
|
l.add(new StringTask()); |
859 |
|
String result = e.invokeAny(l, LONG_DELAY_MS, MILLISECONDS); |
869 |
|
ExecutorService e = new ForkJoinPool(1); |
870 |
|
try (PoolCleaner cleaner = cleaner(e)) { |
871 |
|
try { |
872 |
< |
e.invokeAll(null, MEDIUM_DELAY_MS, MILLISECONDS); |
872 |
> |
e.invokeAll(null, randomTimeout(), randomTimeUnit()); |
873 |
|
shouldThrow(); |
874 |
|
} catch (NullPointerException success) {} |
875 |
|
} |
881 |
|
public void testTimedInvokeAllNullTimeUnit() throws Throwable { |
882 |
|
ExecutorService e = new ForkJoinPool(1); |
883 |
|
try (PoolCleaner cleaner = cleaner(e)) { |
884 |
< |
List<Callable<String>> l = new ArrayList<Callable<String>>(); |
884 |
> |
List<Callable<String>> l = new ArrayList<>(); |
885 |
|
l.add(new StringTask()); |
886 |
|
try { |
887 |
< |
e.invokeAll(l, MEDIUM_DELAY_MS, null); |
887 |
> |
e.invokeAll(l, randomTimeout(), null); |
888 |
|
shouldThrow(); |
889 |
|
} catch (NullPointerException success) {} |
890 |
|
} |
891 |
|
} |
892 |
|
|
893 |
|
/** |
894 |
< |
* timed invokeAll(empty collection) returns empty collection |
894 |
> |
* timed invokeAll(empty collection) returns empty list |
895 |
|
*/ |
896 |
|
public void testTimedInvokeAll2() throws InterruptedException { |
897 |
|
ExecutorService e = new ForkJoinPool(1); |
898 |
+ |
final Collection<Callable<String>> emptyCollection |
899 |
+ |
= Collections.emptyList(); |
900 |
|
try (PoolCleaner cleaner = cleaner(e)) { |
901 |
|
List<Future<String>> r |
902 |
< |
= e.invokeAll(new ArrayList<Callable<String>>(), |
903 |
< |
MEDIUM_DELAY_MS, MILLISECONDS); |
902 |
> |
= e.invokeAll(emptyCollection, |
903 |
> |
randomTimeout(), randomTimeUnit()); |
904 |
|
assertTrue(r.isEmpty()); |
905 |
|
} |
906 |
|
} |
911 |
|
public void testTimedInvokeAll3() throws InterruptedException { |
912 |
|
ExecutorService e = new ForkJoinPool(1); |
913 |
|
try (PoolCleaner cleaner = cleaner(e)) { |
914 |
< |
List<Callable<String>> l = new ArrayList<Callable<String>>(); |
914 |
> |
List<Callable<String>> l = new ArrayList<>(); |
915 |
|
l.add(new StringTask()); |
916 |
|
l.add(null); |
917 |
|
try { |
918 |
< |
e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS); |
918 |
> |
e.invokeAll(l, randomTimeout(), randomTimeUnit()); |
919 |
|
shouldThrow(); |
920 |
|
} catch (NullPointerException success) {} |
921 |
|
} |
927 |
|
public void testTimedInvokeAll4() throws Throwable { |
928 |
|
ExecutorService e = new ForkJoinPool(1); |
929 |
|
try (PoolCleaner cleaner = cleaner(e)) { |
930 |
< |
List<Callable<String>> l = new ArrayList<Callable<String>>(); |
930 |
> |
List<Callable<String>> l = new ArrayList<>(); |
931 |
|
l.add(new NPETask()); |
932 |
|
List<Future<String>> futures |
933 |
|
= e.invokeAll(l, LONG_DELAY_MS, MILLISECONDS); |
947 |
|
public void testTimedInvokeAll5() throws Throwable { |
948 |
|
ForkJoinPool e = new ForkJoinPool(1); |
949 |
|
try (PoolCleaner cleaner = cleaner(e)) { |
950 |
< |
List<Callable<String>> l = new ArrayList<Callable<String>>(); |
950 |
> |
List<Callable<String>> l = new ArrayList<>(); |
951 |
|
l.add(new StringTask()); |
952 |
|
l.add(new StringTask()); |
953 |
|
List<Future<String>> futures |