Java ExecutorService.invokeAll方法代码示例

import java.util.concurrent.ExecutorService; //导入方法依赖的package包/类
/**
 * get of element of invokeAll(c) throws exception on failed task
 */
public void testTimedInvokeAll4() throws Exception {
    final ExecutorService e = new ScheduledThreadPoolExecutor(2);
    try (PoolCleaner cleaner = cleaner(e)) {
        List<Callable<String>> l = new ArrayList<>();
        l.add(new NPETask());
        List<Future<String>> futures =
            e.invokeAll(l, LONG_DELAY_MS, MILLISECONDS);
        assertEquals(1, futures.size());
        try {
            futures.get(0).get();
            shouldThrow();
        } catch (ExecutionException success) {
            assertTrue(success.getCause() instanceof NullPointerException);
        }
    }
}
 

import java.util.concurrent.ExecutorService; //导入方法依赖的package包/类
@Override
public Set<NitriteId> apply(final NitriteMap<NitriteId, Document> documentMap) {
    Set<NitriteId> result = new LinkedHashSet<>();
    ExecutorService executorService = nitriteService.getNitriteContext().getWorkerPool();

    try {
        List<Callable<Set<NitriteId>>> tasks = createTasks(filters, documentMap);

        List<Future<Set<NitriteId>>> futures = executorService.invokeAll(tasks);
        for (Future<Set<NitriteId>> future : futures) {
            Set<NitriteId> nitriteIds = future.get();
            if (nitriteIds != null) {
                result.addAll(nitriteIds);
            }
        }
    } catch (FilterException fe) {
        throw fe;
    } catch (Throwable t) {
        throw new FilterException(INVALID_OR_FILTER, t);
    }

    return result;
}
 

import java.util.concurrent.ExecutorService; //导入方法依赖的package包/类
/**
 * timed invokeAll(c) throws NPE if c has null elements
 */
public void testTimedInvokeAll3() throws Exception {
    final ExecutorService e =
        new CustomTPE(2, 2,
                      LONG_DELAY_MS, MILLISECONDS,
                      new ArrayBlockingQueue<Runnable>(10));
    try (PoolCleaner cleaner = cleaner(e)) {
        List<Callable<String>> l = new ArrayList<>();
        l.add(new StringTask());
        l.add(null);
        try {
            e.invokeAll(l, randomTimeout(), randomTimeUnit());
            shouldThrow();
        } catch (NullPointerException success) {}
    }
}
 

import java.util.concurrent.ExecutorService; //导入方法依赖的package包/类
/**
 * get of element of invokeAll(c) throws exception on failed task
 */
public void testInvokeAll4() throws Exception {
    final ExecutorService e =
        new CustomTPE(2, 2,
                      LONG_DELAY_MS, MILLISECONDS,
                      new ArrayBlockingQueue<Runnable>(10));
    try (PoolCleaner cleaner = cleaner(e)) {
        List<Callable<String>> l = new ArrayList<>();
        l.add(new NPETask());
        List<Future<String>> futures = e.invokeAll(l);
        assertEquals(1, futures.size());
        try {
            futures.get(0).get();
            shouldThrow();
        } catch (ExecutionException success) {
            assertTrue(success.getCause() instanceof NullPointerException);
        }
    }
}
 

import java.util.concurrent.ExecutorService; //导入方法依赖的package包/类
/**
 * get of returned element of invokeAll(c) throws exception on failed task
 */
public void testTimedInvokeAll4() throws Exception {
    final ExecutorService e = new DirectExecutorService();
    try (PoolCleaner cleaner = cleaner(e)) {
        List<Callable<String>> l = new ArrayList<>();
        l.add(new NPETask());
        List<Future<String>> futures =
            e.invokeAll(l, LONG_DELAY_MS, MILLISECONDS);
        assertEquals(1, futures.size());
        try {
            futures.get(0).get();
            shouldThrow();
        } catch (ExecutionException success) {
            assertTrue(success.getCause() instanceof NullPointerException);
        }
    }
}
 

import java.util.concurrent.ExecutorService; //导入方法依赖的package包/类
/**
 * invokeAll(c) returns results of all completed tasks
 */
public void testInvokeAll5() throws Exception {
    final ExecutorService e =
        new CustomTPE(2, 2,
                      LONG_DELAY_MS, MILLISECONDS,
                      new ArrayBlockingQueue<Runnable>(10));
    try (PoolCleaner cleaner = cleaner(e)) {
        List<Callable<String>> l = new ArrayList<>();
        l.add(new StringTask());
        l.add(new StringTask());
        List<Future<String>> futures = e.invokeAll(l);
        assertEquals(2, futures.size());
        for (Future<String> future : futures)
            assertSame(TEST_STRING, future.get());
    }
}
 

import java.util.concurrent.ExecutorService; //导入方法依赖的package包/类
/**
 * get of element of invokeAll(c) throws exception on failed task
 */
public void testTimedInvokeAll4() throws Exception {
    final ExecutorService e = new CustomExecutor(2);
    final Collection<Callable<String>> c = new ArrayList<>();
    c.add(new NPETask());
    try (PoolCleaner cleaner = cleaner(e)) {
        List<Future<String>> futures =
            e.invokeAll(c, LONG_DELAY_MS, MILLISECONDS);
        assertEquals(1, futures.size());
        try {
            futures.get(0).get();
            shouldThrow();
        } catch (ExecutionException success) {
            assertTrue(success.getCause() instanceof NullPointerException);
        }
    }
}
 

import java.util.concurrent.ExecutorService; //导入方法依赖的package包/类
/**
 * invokeAll(c) returns results of all completed tasks
 */
public void testInvokeAll5() throws Exception {
    final ExecutorService e = new CustomExecutor(2);
    try (PoolCleaner cleaner = cleaner(e)) {
        List<Callable<String>> l = new ArrayList<>();
        l.add(new StringTask());
        l.add(new StringTask());
        List<Future<String>> futures = e.invokeAll(l);
        assertEquals(2, futures.size());
        for (Future<String> future : futures)
            assertSame(TEST_STRING, future.get());
    }
}
 

import java.util.concurrent.ExecutorService; //导入方法依赖的package包/类
/**
 * timed invokeAll(,,null) throws NullPointerException
 */
public void testTimedInvokeAllNullTimeUnit() throws Exception {
    final ExecutorService e = new CustomExecutor(2);
    try (PoolCleaner cleaner = cleaner(e)) {
        List<Callable<String>> l = new ArrayList<>();
        l.add(new StringTask());
        try {
            e.invokeAll(l, randomTimeout(), null);
            shouldThrow();
        } catch (NullPointerException success) {}
    }
}
 

import java.util.concurrent.ExecutorService; //导入方法依赖的package包/类
/**
 * timed invokeAll(c) cancels tasks not completed by timeout
 */
public void testTimedInvokeAll6() throws Exception {
    for (long timeout = timeoutMillis();;) {
        final CountDownLatch done = new CountDownLatch(1);
        final Callable<String> waiter = new CheckedCallable<String>() {
            public String realCall() {
                try { done.await(LONG_DELAY_MS, MILLISECONDS); }
                catch (InterruptedException ok) {}
                return "1"; }};
        final ExecutorService p = new CustomExecutor(2);
        try (PoolCleaner cleaner = cleaner(p, done)) {
            List<Callable<String>> tasks = new ArrayList<>();
            tasks.add(new StringTask("0"));
            tasks.add(waiter);
            tasks.add(new StringTask("2"));
            long startTime = System.nanoTime();
            List<Future<String>> futures =
                p.invokeAll(tasks, timeout, MILLISECONDS);
            assertEquals(tasks.size(), futures.size());
            assertTrue(millisElapsedSince(startTime) >= timeout);
            for (Future future : futures)
                assertTrue(future.isDone());
            assertTrue(futures.get(1).isCancelled());
            try {
                assertEquals("0", futures.get(0).get());
                assertEquals("2", futures.get(2).get());
                break;
            } catch (CancellationException retryWithLongerTimeout) {
                timeout *= 2;
                if (timeout >= LONG_DELAY_MS / 2)
                    fail("expected exactly one task to be cancelled");
            }
        }
    }
}
 

import java.util.concurrent.ExecutorService; //导入方法依赖的package包/类
/**
 * invokeAll(empty collection) returns empty list
 */
public void testInvokeAll2() throws Exception {
    final ExecutorService e = new CustomExecutor(2);
    final Collection<Callable<String>> emptyCollection
        = Collections.emptyList();
    try (PoolCleaner cleaner = cleaner(e)) {
        List<Future<String>> r = e.invokeAll(emptyCollection);
        assertTrue(r.isEmpty());
    }
}
 

import java.util.concurrent.ExecutorService; //导入方法依赖的package包/类
public void testCreatedFlagParallelExecution() throws Exception {
    createIndex("test");
    ensureGreen();

    int threadCount = 20;
    final int docCount = 300;
    int taskCount = docCount * threadCount;

    final AtomicIntegerArray createdCounts = new AtomicIntegerArray(docCount);
    ExecutorService threadPool = Executors.newFixedThreadPool(threadCount);
    List<Callable<Void>> tasks = new ArrayList<>(taskCount);
    final Random random = random();
    for (int i=0;i< taskCount; i++ ) {
        tasks.add(new Callable<Void>() {
            @Override
            public Void call() throws Exception {
                int docId = random.nextInt(docCount);
                IndexResponse indexResponse = index("test", "type", Integer.toString(docId), "field1", "value");
                if (indexResponse.getResult() == DocWriteResponse.Result.CREATED) {
                    createdCounts.incrementAndGet(docId);
                }
                return null;
            }
        });
    }

    threadPool.invokeAll(tasks);

    for (int i=0;i<docCount;i++) {
        assertThat(createdCounts.get(i), lessThanOrEqualTo(1));
    }
    terminate(threadPool);
}
 

import java.util.concurrent.ExecutorService; //导入方法依赖的package包/类
/**
 * timed invokeAll(,,null) throws NPE
 */
public void testTimedInvokeAllNullTimeUnit() throws Exception {
    final ExecutorService e =
        new ThreadPoolExecutor(2, 2,
                               LONG_DELAY_MS, MILLISECONDS,
                               new ArrayBlockingQueue<Runnable>(10));
    try (PoolCleaner cleaner = cleaner(e)) {
        List<Callable<String>> l = new ArrayList<>();
        l.add(new StringTask());
        try {
            e.invokeAll(l, randomTimeout(), null);
            shouldThrow();
        } catch (NullPointerException success) {}
    }
}
 

import java.util.concurrent.ExecutorService; //导入方法依赖的package包/类
/**
 * timed invokeAll(null) throws NullPointerException
 */
public void testTimedInvokeAll1() throws Throwable {
    ExecutorService e = new ForkJoinPool(1);
    try (PoolCleaner cleaner = cleaner(e)) {
        try {
            e.invokeAll(null, randomTimeout(), randomTimeUnit());
            shouldThrow();
        } catch (NullPointerException success) {}
    }
}
 

import java.util.concurrent.ExecutorService; //导入方法依赖的package包/类
/**
 * timed invokeAll(,,null) throws NPE
 */
public void testTimedInvokeAllNullTimeUnit() throws Exception {
    final ExecutorService e = new ScheduledThreadPoolExecutor(2);
    try (PoolCleaner cleaner = cleaner(e)) {
        List<Callable<String>> l = new ArrayList<>();
        l.add(new StringTask());
        try {
            e.invokeAll(l, randomTimeout(), null);
            shouldThrow();
        } catch (NullPointerException success) {}
    }
}