24点多线程版

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveAction;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;

import static com.activiti6.Main.FA;

class NumEntity{
    String path="";
    double num;
}
class State extends RecursiveAction {
    NumEntity[] numEntities;
    double target;
    static AtomicLong count=new AtomicLong(0);
    public State(NumEntity[] numEntities, double target) {
        this.numEntities = numEntities;
        this.target = target;
    }

    @Override
    protected void compute() {
        count.incrementAndGet();
        if(numEntities.length==1){
            if(Math.abs( numEntities[0].num-target)<=FA){
                System.out.println(numEntities[0].path);
            }
            return;
        }

        NumEntity last=numEntities[numEntities.length-1];
        List<State> states=new ArrayList<>();
        for(int i=0;i<=numEntities.length-2;++i){
            for(int j=i+1;j<=numEntities.length-1;++j){

                //+
                NumEntity newEntity=new NumEntity();
                newEntity.path="("+numEntities[i].path+"+"+numEntities[j].path+")";
                newEntity.num=numEntities[i].num+numEntities[j].num;

                State state1=new State( Main.getNewArr(numEntities, i, j, newEntity),target);
                states.add(state1);

                //*
                newEntity=new NumEntity();
                newEntity.path="("+numEntities[i].path+"*"+numEntities[j].path+")";
                newEntity.num=numEntities[i].num*numEntities[j].num;

                states.add(new State( Main.getNewArr(numEntities, i, j, newEntity),target));

                //-1
                newEntity=new NumEntity();
                newEntity.path="("+numEntities[i].path+"-"+numEntities[j].path+")";
                newEntity.num=numEntities[i].num-numEntities[j].num;

                states.add(new State( Main.getNewArr(numEntities, i, j, newEntity),target));



                //-2
                newEntity=new NumEntity();
                newEntity.path="("+numEntities[j].path+"-"+numEntities[i].path+")";
                newEntity.num=numEntities[j].num-numEntities[i].num;

                states.add(new State( Main.getNewArr(numEntities, i, j, newEntity),target));

                // chu1
                if(Math.abs (numEntities[j].num-0)>FA){
                    newEntity=new NumEntity();
                    newEntity.path="("+numEntities[i].path+"/"+numEntities[j].path+")";
                    newEntity.num=numEntities[i].num/numEntities[j].num;

                    states.add(new State( Main.getNewArr(numEntities, i, j, newEntity),target));

                }

                // chu2
                if(Math.abs (numEntities[i].num-0)>FA){
                    newEntity=new NumEntity();
                    newEntity.path="("+numEntities[j].path+"/"+numEntities[i].path+")";
                    newEntity.num=numEntities[j].num/numEntities[i].num;

                    states.add(new State( Main.getNewArr(numEntities, i, j, newEntity),target));

                }
            }
        }

        for(State state:states){
            state.fork();
        }
        for(State state:states){
            state.join();
        }
    }
}
public class Main {
    public static final double FA=0.00001;
    static NumEntity[] getNewArr(NumEntity[] numEntities,int i,int j,NumEntity e){
        NumEntity[] newArr=new NumEntity[numEntities.length-1];
        int index=-1;
        for(int jj=0;jj<numEntities.length;++jj){
            if(jj==i||jj==j){
                continue;
            }
            newArr[++index]=numEntities[jj];
        }
        newArr[++index]=e;
        return newArr;
    }


    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // TODO Auto-generated method stub
//        System.out.println((((-1.0+231.0)*((7.0+8.0)+((1.0+2.0)-(9.0+0.0))))-((5.0+6.0)*((3.0+4.0)-((60.0*30.0)+(20.0+10.0))))));
        double[] nn={60,30,20,10,1,2,9};
        NumEntity[] entities=new NumEntity[nn.length];
        for(int i=0;i<nn.length;++i){
            NumEntity e=new NumEntity();
            e.num=nn[i];
            e.path=String.valueOf(e.num);
            entities[i]=e;
        }

        State start=new State(entities,22258024);

        ForkJoinPool forkJoinPool=new ForkJoinPool(10);

//        new Thread(new Runnable() {
//            @Override
//            public void run() {
//                while (true){
//                    System.out.println(forkJoinPool.getStealCount());
//
//                    try {
//                        Thread.sleep(3000);
//                    } catch (InterruptedException e) {
//                        e.printStackTrace();
//                    }
//                }
//            }
//        }).start();
        System.out.println(forkJoinPool.getParallelism());
        forkJoinPool.submit(start);

        long startTime=System.currentTimeMillis();
        start.get();
        System.out.println(System.currentTimeMillis()-startTime);
        System.out.println(State.count.longValue());


    }

}