Java 递归运行非常慢-异步任务

我正在尝试制作一个TictaToe游戏，在这个游戏中，计算机试图赢而不是输——虽然部分工作正常，但代码在Android上运行非常缓慢，但在计算机上运行良好

计算机的决定是在

AsynTask

中做出的，

doInBackground

调用一个UI方法

我不断得到：

D/dalvikvm（14142）：GC_并发释放1924K，15%释放26534K/30996K，暂停2ms+11ms，总计136ms

及

D/dalvikvm（14142）：分配释放1711K的GC，12%释放24208K/27304K，暂停106ms，总计106ms

这是代码，或者在这里：

AI:

void AI(int i, int j, CompNode cNode, String [][] fake, int depth){
    //task.doProgress(1);
    depth++;
    //System.out.println("In AI");
    //System.out.println("Depth: "+ depth);
    fake[i][j] =  getLetter(current_player); 
    //print(fake);
    boolean winner = CheckWinner(1, fake);
    if(winner){
        //System.out.println("Winner move found");
        //print(fake);
        //cNode.value= 1000;
        if(bestwin_depth >= depth){
            bestwin_depth = depth;
            bestwin = i+"/"+j;
        }
        bestMoves.add(i+"/"+j);
        WINNER_FOUND = false;
        game_winner = false;
        is_draw = false;
        return;
    }
    if(is_draw == true){
        //System.out.println("Draw found or no more space");
        drawMoves.add(i+"/"+j);
        WINNER_FOUND = false;
        game_winner = false;
        is_draw = false;
        return;
    }

    /*  check if game over on move
        if over 
            return
        if not over for comp

    */ 
    ArrayList<String> indexes = getLegalMoves(fake);
    //System.out.println("Legal Moves: "+ indexes.size());
    if(indexes.size() ==0){
        //System.out.println("Draw found or no more space");
        if(bestdraw_depth >= depth){
            bestdraw_depth = depth;
            bestdraw = i+"/"+j;
        }   
        drawMoves.add(i+"/"+j);
        return;
    }
    //permute (indexes, 0, i, j, cNode, fake);
    cNode = new CompNode(indexes.size(), i , j);

    Iterator sets = indexes.iterator();
    PlayerNode [] possibleMove = cNode.children;
    int k =0;


    while (sets.hasNext() ) {
        String index = (String) sets.next();

        String [] index_ =  index.split("/");
        int x = Integer.parseInt(index_[0]);
        int y = Integer.parseInt(index_[1]);

        //System.out.println("( "+x + ", " +y + " )");
        possibleMove[k] = new PlayerNode(indexes.size()-1, x, y);
        String [][]temp = fake;
        playerMove(x, y , possibleMove[k], temp, depth);
        //depth--;

        fake[x][y] = "-";
        k++;
    }
    //System.exit(0);
}

PlayerNode类

class PlayerNode {
    CompNode [] children;

    PlayerNode(int num, int i , int j){
    this.children = new CompNode[num];
    }
}

CompNode类：

class CompNode {
    PlayerNode [] children;

    CompNode(int num, int i, int j){
        this.children = new PlayerNode[num];
    }
}

ComputerPromptInputandSet

在我的手机上运行需要52秒，在模拟器上运行需要2分钟，在另一部手机上运行需要34秒

以下是统计屏幕截图：

---

我怎样才能解决这个问题？

你的电脑比你的手机快500倍，我说得对吗？这很可能是正常的，可能是因为移动内存有限，这将更频繁地调用垃圾收集器

一般优化应该可以解决这个问题

---

代码非常复杂，我并不真正理解它，但如果getLegalMoves方法实现了我认为您应该能够极大地优化它，通过消除在同一x轴和y轴以及对角线上已经有玩家交叉的移动，返回不太可能的移动。在simple中也有相当大的潜力改进措施，如在线路板上使用字符[]，而不是字符串[]。此外，移动可以在单个int中编码（为此使用row或甚至布尔值[][]）（null不是标记，true是O，false是X）。

void playerMove(int i, int j, PlayerNode pNode, String [][]fake, int depth){
    //task.doProgress(1);
    depth++;
    //System.out.println("In playMove");
    //System.out.println("Player move: ");
    //System.out.println("Depth: "+ depth);
    fake[i][j] =  getOtherLetter(current_player); 
    //print(fake);

    boolean winner = CheckWinner(0, fake);
    pNode = new PlayerNode(0, 0, 0);
    if(winner){
        //System.out.println("Player winning move");
        if(bestlose_depth >= depth){
            bestlose_depth = depth;
            bestlose = i+"/"+j;
        } 
       // pNode.value= -1000;
        WINNER_FOUND = false;
        game_winner = false;
        is_draw = false;
        return;
    }
    if(is_draw == true){
        //System.out.println("Draw found or no more space");
        drawMoves.add(i+"/"+j);
        WINNER_FOUND = false;
        game_winner = false;
        is_draw = false;
        return;
    }

    ArrayList<String> indexes = getLegalMoves(fake);
    //System.out.println("Legal Moves: "+ indexes.size());
    if(indexes.size() ==0){
        //System.out.println("Draw found or no more space");
        if(bestdraw_depth >= depth){
            bestdraw_depth = depth;
            bestdraw = i+"/"+j;
        } 

        drawMoves.add(i+"/"+j);
        return;
    }
    //permutePlayer (indexes, 0, i, j, pNode, fake);
    pNode = new PlayerNode(indexes.size(), i , j);

    Iterator sets = indexes.iterator();
    CompNode [] possibleMove = pNode.children;
    int k =0;


    while (sets.hasNext() ) {
        String index = (String) sets.next();

        String [] index_ =  index.split("/");
        int x = Integer.parseInt(index_[0]);
        int y = Integer.parseInt(index_[1]);

        //System.out.println("( "+x + ", " +y + " )");
        possibleMove[k] = new CompNode(indexes.size()-1, x, y);
        String [][] temp = fake;
        AI(x, y , possibleMove[k], temp, depth);
        //depth--;
        fake[x][y] = "-";
        k++;
    }
    //System.exit(0);
}

class PlayerNode {
    CompNode [] children;

    PlayerNode(int num, int i , int j){
    this.children = new CompNode[num];
    }
}

class CompNode {
    PlayerNode [] children;

    CompNode(int num, int i, int j){
        this.children = new PlayerNode[num];
    }
}