我知道在JavaEE应用程序中分离线程是一个很大的禁忌.但是,我有一个应用程序是Java的fork/join机制的完美候选者.但是,由于不应该在应用程序中创建线程,有没有办法在我的EJB中使用它？我知道在WebSphere应用程序中,异步bean功能提供了这一功能.但是,我的应用程序部署在JBoss EAP 6.1上,所以这不是一个选项.
在JavaEE应用程序中是否有"合法"的方法来完成fork/join？
我想知道是否有一种方法可以在scala中的另一个线程上执行非常简单的任务,而这些任务没有很多开销？
基本上我想创建一个可以处理执行任意数量任务的全局"执行器".然后我可以使用执行程序来构建其他构造.
此外,如果客户端不必考虑阻塞或非阻塞因素,那将是很好的.
我知道scala actor库是建立在Doug Lea FJ之上的,而且他们在有限的程度上支持我想要完成的事情.但是根据我的理解,我将不得不预先分配一个'Actor Pool'来完成.
我想避免为此创建一个全局线程池,因为据我所知,它在细粒度并行性方面并不是那么好.
这是一个简单的例子:
import concurrent.SyncVar
object SimpleExecutor {
import actors.Actor._
def exec[A](task: => A) : SyncVar[A] = {
//what goes here?
//This is what I currently have
val x = new concurrent.SyncVar[A]
//The overhead of making the actor appears to be a killer
actor {
x.set(task)
}
x
}
//Not really sure what to stick here
def execBlocker[A](task: => A) : SyncVar[A] = exec(task)
}
现在使用exec的一个例子:
object Examples {
//Benchmarks a task
def …我正在尝试通过分而治之的策略来实现阶乘功能。我使用ForkJoin框架来分叉每个递归任务，以加快计算速度。但是我发现它没有按照我的预期加速。在不使用ForkJoin的情况下，花了28秒来计算50000的阶乘，而在我使用ForkJoin时，花了25秒。这是没有forkjoin的代码：
public static BigInteger factorial(long p, long q) {
if (q < p) {
return new BigInteger("1");
}
if (p == q) {
return new BigInteger("" + p);
}
BigInteger fact = new BigInteger("1");
fact = fact.multiply(factorial(p, (p + q) / 2)).multiply(factorial((p + q) / 2 + 1, q));
return fact;
}
这是forkJoin的代码：
public class Factorial extends RecursiveTask<BigInteger>{
private long p, q;
public Factorial(long p, long q) {
this.p = p;
this.q = q;
}
@Override
public BigInteger compute() { …如果我有2个CPU并为fork/join框架安排1000个任务,那么一次最多可以执行2个任务,还是在同一个CPU上并行执行更多任务？(比方说,也许一个任务正在等待I/O,在这种情况下CPU会变为空闲而另一个线程可以运行)
我想改进我的fork/join小例子,以表明在Java Fork/Join框架执行工作中发生窃取.
我需要对代码进行哪些更改？示例目的:只需对多个线程之间的值分解进行线性研究.
package com.stackoverflow.questions;
import java.util.LinkedList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveTask;
public class CounterFJ<T extends Comparable<T>> extends RecursiveTask<Integer> {
private static final long serialVersionUID = 5075739389907066763L;
private List<T> _list;
private T _test;
private int _lastCount = -1;
private int _start;
private int _end;
private int _divideFactor = 4;
private static final int THRESHOLD = 20;
public CounterFJ(List<T> list, T test, int start, int end, int factor) {
_list = list;
_test = test;
_start = start; …我正在使用jmh 使用maven并按照http://openjdk.java.net/projects/code-tools中建议的命令行方法对一个简单的应用程序进行基准测试（来自Java派生出java fork-join中的Unexpected Scalability结果）/ jmh /。成功设置并建立基准后，我可以使用avgt模式获得以下基准结果：
C:\Users\username\my-app\test>java -jar target/benchmarks.jar -bm avgt -f 1
# JMH 1.10.1 (released 13 days ago)
# VM invoker: C:\Program Files\Java\jre1.8.0_45\bin\java.exe
# VM options: <none>
# Warmup: 20 iterations, 1 s each
# Measurement: 20 iterations, 1 s each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: org.sample.MyBenchmark.testMethod
# Run progress: 0,00% complete, ETA 00:00:40
# Fork: …在角度2我使用多个服务,但我无法从第二个API的订阅功能获得第一个Api的数据,所以请建议我合适的答案.
我发现的大多数归并排序示例都在单个线程中运行。这首先就抵消了使用合并排序算法的一些优势。有人可以展示使用多线程在 java 中编写合并排序算法的正确方法吗？
该解决方案应使用最新版本的 java 的适用功能。Stackoverflow 上已有的许多解决方案都使用普通线程。我正在寻找一个演示 ForkJoin 与 RecursiveTask 的解决方案，这似乎是 RecursiveTask 类的主要用例。
重点应该是展示一种具有卓越性能特征的算法，包括尽可能的时间和空间复杂度。
注意：所提议的重复问题都不适用，因为两者都没有提供使用递归任务的解决方案，而这正是该问题所要求的。
两者都用于连接多个流。
由此 我对两者感到困惑，我读了combineLatest在同步模式下进行调用和forkJoin并行调用，
我正在尝试这个
combineLatest([
of(null).pipe(delay(5000)),
of(null).pipe(delay(5000)),
of(null).pipe(delay(5000))
]).subscribe(() => console.log(new Date().getTime() - start));
forkJoin([
of(null).pipe(delay(5000)),
of(null).pipe(delay(5000)),
of(null).pipe(delay(5000))
]).subscribe(() => console.log(new Date().getTime() - start));
打印
5004
5014
每次结果约为5秒，如果combineLatest按顺序发送请求，那么为什么它打印持续时间约为5秒。
这是正确的还是有其他区别，有示例代码吗？
我检查了我的项目，发现 forkjoin 已被弃用，因为forkjoin它已从 Angular 中弃用，最好的选择是什么？