Java 分叉和联接功能jdk7线程数
我一直在研究JDK 7中的新特性,即Fork和Join。在Javadoc中,它指出在Java 分叉和联接功能jdk7线程数,java,multithreading,concurrency,java-7,Java,Multithreading,Concurrency,Java 7,我一直在研究JDK 7中的新特性,即Fork和Join。在Javadoc中,它指出在ForkJoinTask中,不能仅在ForkJoinPool的上下文中执行fork。但是它没有提到fork()方法调用是否创建了一个新线程 ForkJoinPool使用工作窃取算法来平衡线程之间的工作,但没有提到实际创建了多少线程 我有一个任务,我应该以某种方式分解它,但我担心ForkJoinPool会创建太多线程,并且会因为管理这些线程的开销而降低执行性能 有人能帮我吗 Fork(不一定)创建新线程。在我的基准
ForkJoinTask
中,不能仅在ForkJoinPool
的上下文中执行fork。但是它没有提到fork()
方法调用是否创建了一个新线程
ForkJoinPool
使用工作窃取算法来平衡线程之间的工作,但没有提到实际创建了多少线程
我有一个任务,我应该以某种方式分解它,但我担心ForkJoinPool
会创建太多线程,并且会因为管理这些线程的开销而降低执行性能
有人能帮我吗 Fork(不一定)创建新线程。在我的基准测试中,它仅为每个可用核心创建1个线程+1个额外线程。附加基准;例如,从main()调用Factorizer.factorize(71236789143834319L)
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveTask;
public class Factorizer extends RecursiveTask<Long> {
static ForkJoinPool fjPool = new ForkJoinPool();
static final int sequentialThreshold = 10000;
private long number, low, high;
Factorizer(long number, long low, long high) {
this.number = number; this.low = low; this.high = high;
}
private long factorize() {
if ((number % 2) == 0) {
return 2;
}
// ensures i is odd (we already know number is not even)
long i = ((low % 2) == 0) ? low + 1: low;
for (/**/; i < high; i+=2) {
if ((number % i) == 0) {
return i;
}
}
return number;
}
@Override
protected Long compute() {
// ugly debug statement counts active threads
System.err.println(Thread.enumerate(
new Thread[Thread.activeCount()*2]));
if (high - low <= sequentialThreshold) {
return factorize();
} else {
long mid = low + (high - low) / 2;
Factorizer left = new Factorizer(number, low, mid);
Factorizer right = new Factorizer(number, mid, high);
left.fork();
return Math.min(right.compute(), left.join());
}
}
static long factorize(long num) {
return fjPool.invoke(new Factorizer(num, 2, (long)Math.sqrt(num+1)));
}
}
import java.util.concurrent.ForkJoinPool;
导入java.util.concurrent.RecursiveTask;
公共类分解器扩展递归任务{
静态ForkJoinPool fjPool=新的ForkJoinPool();
静态最终int顺序阈值=10000;
私人长数,低,高;
因子分解器(长数、长低、长高){
this.number=number;this.low=low;this.high=high;
}
私有长因子分解(){
如果((数字%2)=0){
返回2;
}
//确保i为奇数(我们已经知道数字不是偶数)
长i=((低%2)==0)?低+1:低;
对于(/**;i
,比如说
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveTask;
public class Factorizer extends RecursiveTask<Long> {
static ForkJoinPool fjPool = new ForkJoinPool();
static final int sequentialThreshold = 10000;
private long number, low, high;
Factorizer(long number, long low, long high) {
this.number = number; this.low = low; this.high = high;
}
private long factorize() {
if ((number % 2) == 0) {
return 2;
}
// ensures i is odd (we already know number is not even)
long i = ((low % 2) == 0) ? low + 1: low;
for (/**/; i < high; i+=2) {
if ((number % i) == 0) {
return i;
}
}
return number;
}
@Override
protected Long compute() {
// ugly debug statement counts active threads
System.err.println(Thread.enumerate(
new Thread[Thread.activeCount()*2]));
if (high - low <= sequentialThreshold) {
return factorize();
} else {
long mid = low + (high - low) / 2;
Factorizer left = new Factorizer(number, low, mid);
Factorizer right = new Factorizer(number, mid, high);
left.fork();
return Math.min(right.compute(), left.join());
}
}
static long factorize(long num) {
return fjPool.invoke(new Factorizer(num, 2, (long)Math.sqrt(num+1)));
}
}
import java.util.concurrent.ForkJoinPool;
导入java.util.concurrent.RecursiveTask;
公共类分解器扩展递归任务{
静态ForkJoinPool fjPool=新的ForkJoinPool();
静态最终int顺序阈值=10000;
私人长数,低,高;
因子分解器(长数、长低、长高){
this.number=number;this.low=low;this.high=high;
}
私有长因子分解(){
如果((数字%2)=0){
返回2;
}
//确保i为奇数(我们已经知道数字不是偶数)
长i=((低%2)==0)?低+1:低;
对于(/**;i 如果(高-低我假设Fork-Join的全部目的是将开发人员从这个计算中解放出来,并自动确定给定典型开销和100%并行执行的理想线程数。可能每个内核一个。但我不确定。这也是我的想法,但我不确定,也找不到任何合适的资源at会向我澄清这一点,但未经确认,我无法使用它。额外线程的成本接近于零,因此不值得担心。它比创建太少线程的惩罚低很多数量级,因此创建一些额外线程是常见的。你不应该假设开发你平台的人是白痴d你应该使用他们提供给你的工具达到他们想要的目的。如果他们是白痴,你就完蛋了。你有很多要担心的。[什么决定了Java ForkJoinPool创建的线程数?][1][1]:我假设Fork-Join的全部目的是将开发人员从这种计算中解放出来,并根据典型的开销和100%的并行执行自动确定理想的线程数。可能每个内核一个。但我不确定。这也是我的想法,但我不确定,也找不到任何合适的资源可以向我学习它,未经确认我无法使用它。额外线程的成本接近于零,因此不值得担心。它比创建太少线程的惩罚低很多数量级,因此创建一些额外线程是常见的。你不应该假设开发你平台的人是白痴,你应该我要使用他们给你的工具达到他们想要的目的。如果他们是白痴,你就完蛋了。你有很多要担心的。[什么决定了Java ForkJoinPool创建的线程数?][1][1]: