我想在3D中构建适应性网格细化。
基本原则如下：
我有一组具有唯一单元ID的单元格。 我测试每个细胞，看它是否需要精制。
我想使用ForkJoin框架和Java 8流来实现它。我读过this article，但我不知道如何将它应用到我的案例中。
现在，我想出的是：
public class ForkJoinAttempt {
private final double[] cellIds;
public ForkJoinAttempt(double[] cellIds) {
this.cellIds = cellIds;
}
public void refineGrid() {
ForkJoinPool pool = ForkJoinPool.commonPool();
double[] result = pool.invoke(new RefineTask(100));
}
private class RefineTask extends RecursiveTask<double[]> {
final double cellId;
private RefineTask(double cellId) {
this.cellId = cellId;
}
@Override
protected double[] compute() {
return ForkJoinTask.invokeAll(createSubtasks())
.stream()
.map(ForkJoinTask::join)
.reduce(new double[0], new Concat());
}
}
private double[] refineCell(double cellId) {
double[] result;
if (checkCell()) {
result = new double[8];
for (int i = 0; i < 8; i++) {
result[i] = Math.random();
}
} else {
result = new double[1];
result[0] = cellId;
}
return result;
}
private Collection<RefineTask> createSubtasks() {
List<RefineTask> dividedTasks = new ArrayList<>();
for (int i = 0; i < cellIds.length; i++) {
dividedTasks.add(new RefineTask(cellIds[i]));
}
return dividedTasks;
}
private class Concat implements BinaryOperator<double[]> {
@Override
public double[] apply(double[] a, double[] b) {
int aLen = a.length;
int bLen = b.length;
@SuppressWarnings("unchecked")
double[] c = (double[]) Array.newInstance(a.getClass().getComponentType(), aLen + bLen);
System.arraycopy(a, 0, c, 0, aLen);
System.arraycopy(b, 0, c, aLen, bLen);
return c;
}
}
public boolean checkCell() {
return Math.random() < 0.5;
}
}
......我被困在这里。
现在这没什么用，因为我从不调用refineCell函数。
我创建的所有double[]也可能存在性能问题。以这种方式合并它们可能也不是最有效的方法。
但首先，在这种情况下，任何人都可以帮我实现fork join吗？
算法的预期结果是叶子单元ID（double[]）
感谢评论，我提出了一些更好的方法。
一些变化：
这允许我为了这个例子更好地检查结果。
以下是新实施：
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.concurrent.*;
import java.util.function.BinaryOperator;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;
public class ForkJoinAttempt {
private static final int THRESHOLD = 2;
private List<Long> leafCellIds;
public void refineGrid(List<Long> cellsToProcess) {
leafCellIds = ForkJoinPool.commonPool().invoke(new RefineTask(cellsToProcess));
}
public List<Long> getLeafCellIds() {
return leafCellIds;
}
private class RefineTask extends RecursiveTask<List<Long>> {
private final CopyOnWriteArrayList<Long> cellsToProcess = new CopyOnWriteArrayList<>();
private RefineTask(List<Long> cellsToProcess) {
this.cellsToProcess.addAll(cellsToProcess);
}
@Override
protected List<Long> compute() {
if (cellsToProcess.size() > THRESHOLD) {
System.out.println("Fork/Join");
return ForkJoinTask.invokeAll(createSubTasks())
.stream()
.map(ForkJoinTask::join)
.reduce(new ArrayList<>(), new Concat());
} else {
System.out.println("Direct computation");
List<Long> leafCells = new ArrayList<>();
for (Long cell : cellsToProcess) {
Long result = refineCell(cell);
if (result != null) {
leafCells.add(result);
}
}
return leafCells;
}
}
private Collection<RefineTask> createSubTasks() {
List<RefineTask> dividedTasks = new ArrayList<>();
for (List<Long> list : split(cellsToProcess)) {
dividedTasks.add(new RefineTask(list));
}
return dividedTasks;
}
private Long refineCell(Long cellId) {
if (checkCell(cellId)) {
for (int i = 0; i < 8; i++) {
Long newCell = cellId * 10 + i;
cellsToProcess.add(newCell);
System.out.println("Adding child " + newCell + " to cell " + cellId);
}
return null;
} else {
System.out.println("Leaf node " + cellId);
return cellId;
}
}
private List<List<Long>> split(List<Long> list)
{
int[] index = {0, (list.size() + 1)/2, list.size()};
List<List<Long>> lists = IntStream.rangeClosed(0, 1)
.mapToObj(i -> list.subList(index[i], index[i + 1]))
.collect(Collectors.toList());
return lists;
}
}
private class Concat implements BinaryOperator<List<Long>> {
@Override
public List<Long> apply(List<Long> listOne, List<Long> listTwo) {
return Stream.concat(listOne.stream(), listTwo.stream())
.collect(Collectors.toList());
}
}
public boolean checkCell(Long cellId) {
return cellId < 100;
}
}
测试它的方法：
int initialSize = 4;
List<Long> cellIds = new ArrayList<>(initialSize);
for (int i = 0; i < initialSize; i++) {
cellIds.add(Long.valueOf(i + 1));
}
ForkJoinAttempt test = new ForkJoinAttempt();
test.refineGrid(cellIds);
List<Long> leafCellIds = test.getLeafCellIds();
System.out.println("Leaf nodes: " + leafCellIds.size());
for (Long node : leafCellIds) {
System.out.println(node);
}
输出确认它为每个根单元格添加了8个子节点。但它没有进一步发展。
我知道为什么，但我不知道如何解决它：这是因为即使refineCell方法将新单元格添加到要处理的单元格列表中。不会再次调用createSubTask方法，因此无法知道我添加了新单元格。
要以不同的方式陈述问题，我正在寻找的是一种机制，其中Queue个单元格ID由某些RecursiveTask处理，而其他的并行添加到Queue
答案 0 :(得分：2)
首先，让我们从基于流的解决方案
开始public class Mesh {
public static long[] refineGrid(long[] cellsToProcess) {
return Arrays.stream(cellsToProcess).parallel().flatMap(Mesh::expand).toArray();
}
static LongStream expand(long d) {
return checkCell(d)? LongStream.of(d): generate(d).flatMap(Mesh::expand);
}
private static boolean checkCell(long cellId) {
return cellId > 100;
}
private static LongStream generate(long cellId) {
return LongStream.range(0, 8).map(j -> cellId * 10 + j);
}
}
虽然当前flatMap实现具有known issues并行处理，当网格太不平衡时可能会应用，但实际任务的性能可能是合理的，所以这个简单的解决方案总是值得一试，在开始实施更复杂的事情之前。
如果您确实需要自定义实施，例如如果工作负载不平衡且Stream实现不能很好地适应，你可以这样做：
public class MeshTask extends RecursiveTask<long[]> {
public static long[] refineGrid(long[] cellsToProcess) {
return new MeshTask(cellsToProcess, 0, cellsToProcess.length).compute();
}
private final long[] source;
private final int from, to;
private MeshTask(long[] src, int from, int to) {
source = src;
this.from = from;
this.to = to;
}
@Override
protected long[] compute() {
return compute(source, from, to);
}
private static long[] compute(long[] source, int from, int to) {
long[] result = new long[to - from];
ArrayDeque<MeshTask> next = new ArrayDeque<>();
while(getSurplusQueuedTaskCount()<3) {
int mid = (from+to)>>>1;
if(mid == from) break;
MeshTask task = new MeshTask(source, mid, to);
next.push(task);
task.fork();
to = mid;
}
int pos = 0;
for(; from < to; ) {
long value = source[from++];
if(checkCell(value)) result[pos++]=value;
else {
long[] array = generate(value);
array = compute(array, 0, array.length);
result = Arrays.copyOf(result, result.length+array.length-1);
System.arraycopy(array, 0, result, pos, array.length);
pos += array.length;
}
while(from == to && !next.isEmpty()) {
MeshTask task = next.pop();
if(task.tryUnfork()) {
to = task.to;
}
else {
long[] array = task.join();
int newLen = pos+to-from+array.length;
if(newLen != result.length)
result = Arrays.copyOf(result, newLen);
System.arraycopy(array, 0, result, pos, array.length);
pos += array.length;
}
}
}
return result;
}
static boolean checkCell(long cellId) {
return cellId > 1000;
}
static long[] generate(long cellId) {
long[] sub = new long[8];
for(int i = 0; i < sub.length; i++) sub[i] = cellId*10+i;
return sub;
}
}
此实现直接调用根任务的compute方法，以将调用程序线程合并到计算中。 compute方法使用getSurplusQueuedTaskCount()来决定是否拆分。正如其文件所述，其想法是总是有一个小的盈余，例如3。这可以确保评估可以适应不平衡的工作负载，因为空闲线程可以从其他任务中窃取工作。
拆分不是通过创建两个子任务并等待两者来完成的。相反，只有一个任务被拆分，代表待处理工作的后半部分，并且当前任务的工作量适合于反映上半部分。
然后，在本地处理剩余的工作负载。然后，弹出最后推送的子任务并尝试unfork。如果unforking成功，则当前工作负载的范围也适用于覆盖后续任务的范围，并继续本地迭代。
这样，任何未被另一个线程窃取的剩余任务都以最简单，最轻量级的方式处理，就像从未分叉过一样。
如果任务已被另一个线程拾取，我们必须等待它现在完成并合并结果数组。
请注意，在通过join()等待子任务时，底层实现还将检查是否可以进行重写和本地评估，以保持所有工作线程忙。但是，调整我们的循环变量并直接在目标数组中累积结果仍然比仍需要合并结果数组的嵌套compute调用更好。
如果单元格不是叶子，则生成的节点由相同的逻辑递归处理。这再次允许自适应本地和并发评估，因此执行将适应不平衡的工作负载，例如，如果特定细胞具有更大的子树或者特定细胞的评估比其他细胞更长。
必须强调的是，在所有情况下，需要大量的处理工作量才能从并行处理中获益。如果像在示例中那样，主要是数据复制，那么好处可能会小得多，不存在，或者在最坏的情况下，并行处理可能比顺序处理更差。