无法将java.util.concurrent.ForkJoinWorkerThread强制转换为java.lang.Thread-复杂结构

我理解fork/join的概念，但几乎所有的互联网资源都在使用，比如Fibonacci，但我的场景更复杂。我草拟了程序，我有一个异常，在下面的代码中有注释

Class Test
{

  public static void main(String[] args) 
{

    ForkJoinPool p= new ForkJoinPool(5);
    p.invoke(new Train());
}
}


Class Train extends RecursiveAction
{
public Train(int d, int n)
{
    //some intialization
}
public Train()
{
    t= new Train[5];
    new Vec().run_Vec(t);
}
@Override
protected void compute() {

        for(int i= 1; i< 8; i++)
        {
            // x, and y are predefined
            temp[x][y] = some calculation;

        }

}

}
class Vec
{
    public void run_Vec(Train[] t) {

        for (int i = 0; i < 5; i++) {
            t[i] = new Train(i*4, i/2);
            t[i].fork(); // error java.lang.Thread cannot be cast to   java.util.concurrent.ForkJoinWorkerThread
            }
        for (int i = 0; i < 5; i++) {

            t[i].join();
        }

    }

}
}

类测试
{
公共静态void main（字符串[]args）
{
ForkJoinPool p=新的ForkJoinPool（5）；
p、 调用（newtrain（））；
}
}
类列扩展递归动作
{
公共列车（d点、n点）
{
//一些初始化
}
公共列车（）
{
t=新列车[5]；
new Vec（）。运行_Vec（t）；
}
@凌驾
受保护的void compute（）{
对于（int i=1；i<8；i++）
{
//x和y是预定义的
温度[x][y]=一些计算；
}
}
}
Vec类
{
公共无效运行车辆（列车[]t）{
对于（int i=0；i<5；i++）{
t[i]=新列车（i*4，i/2）；
t[i].fork（）；//错误java.lang.Thread无法转换为java.util.concurrent.ForkJoinWorkerThread
}
对于（int i=0；i<5；i++）{
t[i].join（）；
}
}
}
}

我认为您的问题是由于从主线程调用fork（）造成的。当调用p.invoke（new Train（））时，默认的Train构造函数实际上调用run_vec（）并尝试fork（）。在阅读javadocs时，有一些例子说明在compute（）中调用fork（）。您需要从由p.invoke（）启动的线程调用fork。

基于这篇Java文章，我制作了以下代码片段：

您应该只在“正在运行”的线程中调用

fork

（spawn）。这意味着您必须在

compute

方法中传递列车数组：

package ...;

import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveAction;

class ConcurrentTest {

public static void main(String[] args) {
    ForkJoinPool p= new ForkJoinPool(5);
    p.invoke(new Train());
}


public static class Train extends RecursiveAction {
    private Train[] t = null;
    public Train(int d, int n) {
        //some code
    }

    public Train() {
        t= new Train[5];
    }

    @Override
    protected void compute() {
        if(t != null) {
            new Vec().run_Vec(t);
            for(int i= 1; i< 8; i++) {
                System.out.println("Test.Train.compute(): " + i);   
            }
        }
    }
}


public static class Vec
{
    public void run_Vec(Train[] t) {
        for (int i = 0; i < 5; i++) {
            t[i] = new Train(i*4, i/2);
            System.out.println("Clazz: " + t[i].getClass());
            t[i].fork(); // error java.lang.Thread cannot be cast to   java.util.concurrent.ForkJoinWorkerThread
        }
        for (int i = 0; i < 5; i++) {
            t[i].join();
        }
    }

}
}

包。。。；
导入java.util.concurrent.ForkJoinPool；
导入java.util.concurrent.RecursiveAction；
类并发测试{
公共静态void main（字符串[]args）{
ForkJoinPool p=新的ForkJoinPool（5）；
p、 调用（newtrain（））；
}
公共静态类列扩展递归动作{
私家车[]t=null；
公共列车（d点、n点）{
//一些代码
}
公共列车（）{
t=新列车[5]；
}
@凌驾
受保护的void compute（）{
如果（t！=null）{
new Vec（）。运行_Vec（t）；
对于（int i=1；i<8；i++）{
System.out.println（“Test.Train.compute（）：”+i）；
}
}
}
}
公共静态类Vec
{
公共无效运行车辆（列车[]t）{
对于（int i=0；i<5；i++）{
t[i]=新列车（i*4，i/2）；
System.out.println（“Clazz:+t[i].getClass（））；
t[i].fork（）；//错误java.lang.Thread无法转换为java.util.concurrent.ForkJoinWorkerThread
}
对于（int i=0；i<5；i++）{
t[i].join（）；
}
}
}
}

请原谅我的双重张贴。我仍然觉得有些代码有助于澄清问题（从它的裂缝到它的裂缝）。感谢您的回复，但这将有一个无限循环，因为在run_Vec（t）中，每次t[I]=新的列车（I*4，I/2）时，您都从列车创建一个新的构造函数；这意味着每次都要从同一个类创建一个实例。。在Fork方法上：“只能从ForkJoinPool计算中调用此方法（可以使用方法inForkJoinPool确定）。在其他上下文中尝试调用会导致异常或错误，可能包括ClassCastException。”您只能从

计算（）中调用的内容运行Fork（）。如果不真正了解您正在做什么，您的Train类就不应该既是“作业控制器”又是作业的数据对象。