Java ForkJoinPool.commonPool方法代码示例

import java.util.concurrent.ForkJoinPool; //导入方法依赖的package包/类
@Test
public void testCreateKeyMultithreaded() {
    final int count = 100000;

    final Collection<Callable<String>> tasks = IntStream.range(0, count).boxed()
        .map(i -> (Callable<String>) () -> KeyGenerator.createKey()).collect(Collectors.toList());

    final ForkJoinPool pool = ForkJoinPool.commonPool();

    final List<Future<String>> results = pool.invokeAll(tasks);

    final Set<String> keys = results.stream().map(t -> {
        try {
            return t.get();
        } catch (InterruptedException | ExecutionException e) {
            throw new IllegalStateException(e);
        }
    }).collect(Collectors.toSet());

    Assert.assertEquals("If " + count + " key generations are performed in parallel, it should yield " + count
        + " of distinct keys", count, keys.size());
}
 

import java.util.concurrent.ForkJoinPool; //导入方法依赖的package包/类
public static void dispatch(int trafficUnitsNumber, double timeSec, DateLocation dateLocation, double[] speedLimitByLane) {

        ExecutorService execService =  ForkJoinPool.commonPool();
        try (SubmissionPublisher<Integer> publisher = new SubmissionPublisher<>()){
            subscribe(publisher, execService, Process.AVERAGE_SPEED, timeSec, dateLocation, speedLimitByLane);
            subscribe(publisher, execService, Process.TRAFFIC_DENSITY, timeSec, dateLocation, speedLimitByLane);
            publisher.submit(trafficUnitsNumber);
        } finally {
            try {
                execService.shutdown();
                execService.awaitTermination(1, TimeUnit.SECONDS);
            } catch (Exception ex) {
                System.out.println("Caught around execService.awaitTermination(): " + ex.getClass().getName());
            } finally {
                execService.shutdownNow();
            }
        }
    }
 

import java.util.concurrent.ForkJoinPool; //导入方法依赖的package包/类
private static void demo4_Flow_submissionPublisher() {
    System.out.println();

    ExecutorService execService =  ForkJoinPool.commonPool();//Executors.newFixedThreadPool(3);
    try (SubmissionPublisher<Integer> publisher = new SubmissionPublisher<>()){//execService, 1)){
        demoSubscribe(publisher, execService, "One");
        demoSubscribe(publisher, execService, "Two");
        demoSubscribe(publisher, execService, "Three");
        IntStream.range(1, 5).forEach(publisher::submit);
    } finally {
        try {
            execService.shutdown();
            int shutdownDelaySec = 1;
            System.out.println("Waiting for " + shutdownDelaySec + " sec before shutting down service...");
            execService.awaitTermination(shutdownDelaySec, TimeUnit.SECONDS);
        } catch (Exception ex) {
            System.out.println("Caught around execService.awaitTermination(): " + ex.getClass().getName());
        } finally {
            System.out.println("Calling execService.shutdownNow()...");
            List<Runnable> l = execService.shutdownNow();
            System.out.println(l.size() + " tasks were waiting to be executed. Service stopped.");
        }

    }

}
 

import java.util.concurrent.ForkJoinPool; //导入方法依赖的package包/类
private static void Flow_customsubmissionPublisher() {
    ExecutorService execService =  ForkJoinPool.commonPool();//Executors.newFixedThreadPool(3);
    try (DockerXDemoPublisher<Integer> publisher = new  DockerXDemoPublisher<>(execService)){
        demoSubscribe(publisher,  "One");
        demoSubscribe(publisher,  "Two");
        demoSubscribe(publisher,  "Three");
        IntStream.range(1, 5).forEach(publisher::submit);
    } finally {
        try {
            execService.shutdown();
            int shutdownDelaySec = 1;
            System.out.println("………………等待 " + shutdownDelaySec + " 秒后结束服务……………… ");
            execService.awaitTermination(shutdownDelaySec, TimeUnit.SECONDS);
        } catch (Exception ex) {
            System.out.println("捕获到 execService.awaitTermination()方法的异常: " + ex.getClass().getName());
        } finally {
            System.out.println("调用 execService.shutdownNow()结束服务...");
            List<Runnable> l = execService.shutdownNow();
            System.out.println("还剩 "+l.size() + " 个任务等待被执行，服务已关闭 ");
        }

    }
}
 

import java.util.concurrent.ForkJoinPool; //导入方法依赖的package包/类
private void onCompletedImpl(@NotNull Runnable continuation, boolean useExecutionContext) {
	Executor executor;
	if (continueOnCapturedContext) {
		SynchronizationContext synchronizationContext = SynchronizationContext.getCurrent();
		if (synchronizationContext != null && synchronizationContext.getClass() != SynchronizationContext.class) {
			executor = synchronizationContext;
		} else {
			executor = ForkJoinPool.commonPool();
		}
	} else {
		executor = ForkJoinPool.commonPool();
	}

	Runnable wrappedContinuation = useExecutionContext ? ExecutionContext.wrap(continuation) : continuation;
	future.whenCompleteAsync((result, exception) -> wrappedContinuation.run(), executor);
}
 

import java.util.concurrent.ForkJoinPool; //导入方法依赖的package包/类
private static void demo2_ForkJoin_execute_join() {
    System.out.println();

    AverageSpeed averageSpeed = createTask();

    ForkJoinPool commonPool = ForkJoinPool.commonPool();
    commonPool.execute(averageSpeed);
    double result = averageSpeed.join();

    System.out.println("result = " + result);
}
 

import java.util.concurrent.ForkJoinPool; //导入方法依赖的package包/类
@Setup
public void init() throws Exception {
    repoDir = Files.createTempDirectory("jmh-gitrepository.").toFile();
    repo = new GitRepository(mock(Project.class), repoDir, format, ForkJoinPool.commonPool(),
                             System.currentTimeMillis(), AUTHOR);
    currentRevision = 1;

    for (int i = 0; i < previousCommits; i++) {
        addCommit();
    }
}
 

import java.util.concurrent.ForkJoinPool; //导入方法依赖的package包/类
/**
 * Null-checks user executor argument, and translates uses of
 * commonPool to asyncPool in case parallelism disabled.
 */
static Executor screenExecutor(Executor e) {
    if (!useCommonPool && e == ForkJoinPool.commonPool())
        return asyncPool;
    if (e == null) throw new NullPointerException();
    return e;
}
 

import java.util.concurrent.ForkJoinPool; //导入方法依赖的package包/类
/**
 * A default-constructed SubmissionPublisher has no subscribers,
 * is not closed, has default buffer size, and uses the
 * defaultExecutor
 */
public void testConstructor1() {
    SubmissionPublisher<Integer> p = new SubmissionPublisher<>();
    checkInitialState(p);
    assertEquals(p.getMaxBufferCapacity(), Flow.defaultBufferSize());
    Executor e = p.getExecutor(), c = ForkJoinPool.commonPool();
    if (ForkJoinPool.getCommonPoolParallelism() > 1)
        assertSame(e, c);
    else
        assertNotSame(e, c);
}
 

import java.util.concurrent.ForkJoinPool; //导入方法依赖的package包/类
/**
 * defaultExecutor by default returns the commonPool if
 * it supports more than one thread.
 */
public void testDefaultExecutor() {
    CompletableFuture<Integer> f = new CompletableFuture<>();
    Executor e = f.defaultExecutor();
    Executor c = ForkJoinPool.commonPool();
    if (ForkJoinPool.getCommonPoolParallelism() > 1)
        assertSame(e, c);
    else
        assertNotSame(e, c);
}
 

import java.util.concurrent.ForkJoinPool; //导入方法依赖的package包/类
public LocalComputationManager(LocalComputationConfig config) throws IOException {
    this(config, ForkJoinPool.commonPool());
}
 

import java.util.concurrent.ForkJoinPool; //导入方法依赖的package包/类
@BeforeClass
public static void beforeClass() throws Exception {
    pm = new DefaultProjectManager(rootDir.getRoot(), ForkJoinPool.commonPool(), null);
}
 

import java.util.concurrent.ForkJoinPool; //导入方法依赖的package包/类
private GitRepositoryManager newRepositoryManager() {
    return new GitRepositoryManager(mock(Project.class), rootDir(), ForkJoinPool.commonPool());
}
 

import java.util.concurrent.ForkJoinPool; //导入方法依赖的package包/类
@Before
public void init() throws IOException {
    m = new RepositoryManagerWrapper(new GitRepositoryManager(mock(Project.class), rootDir.getRoot(),
                                                              ForkJoinPool.commonPool()),
                                     RepositoryWrapper::new);
}
 

import java.util.concurrent.ForkJoinPool; //导入方法依赖的package包/类
@BeforeClass
public static void init() throws Exception {
    pm = new DefaultProjectManager(rootDir.getRoot(), ForkJoinPool.commonPool(), null);
}