时间戳

首页 > 解决方案 > 确保两个线程在一个循环中一个接一个 - Android

java - 确保两个线程在一个循环中一个接一个 - Android

问题描述

我有两个这样开始的线程

    Thread player1Thread = new Thread(new Player1RunnableManual());
    player1Thread.start();
    Thread player2Thread = new Thread(new Player2RunnableManual());
    player2Thread.start();

两位玩家，玩家 1 和玩家 2 以不同的方式猜测 100 个数字，一次一个。我们可以忽略他们用来猜测数字的启发式方法。我需要确保 player1 先运行，然后 player2 运行，然后 player1 运行，然后 player2 再次运行，直到其中一个猜到特定数字（硬编码）。

我尝试使用可重入锁，但无法使其工作。player1 和 player2 的可运行文件如下。

如何编写锁实现以使其工作？

class Player1RunnableManual implements Runnable {
    @Override
    public void run() {
        while (!gopherFound) {
            r = new Random();
            final int player1Position = r.nextInt(high - low) + low;
            final int outcome = calculateProximity(player1, player1Position);
            if (outcome != DISASTER) {
                runnableHandler.post(new Runnable() {
                    @Override
                    public void run() {
                        if (holes[player1Position] == 0) {
                            setPosition(player1, player1Position);
                            player1Status.setText(outcomesList[outcome]);
                        }
                    }
                });
                if (outcome == SUCCESS) {
                    gopherFound = true;
                    winner = "Player 1";
                    result.setText("Player 1 wins");
                    break;
                }
            }
            try {
                int sleep = r.nextInt(threadHigh - threadLow) + threadLow;
                Thread.sleep(sleep);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
            }
        }
    }
}


class Player2RunnableManual implements Runnable {

    @Override
    public void run() {
        for (int i = 1; i <= 100 && !gopherFound; i++) {
            final int player2Position = i;
            final int outcome = calculateProximity(player2, player2Position);
            if (outcome != DISASTER) {
                Message msg = messageHandler.obtainMessage(player2);
                msg.arg1 = player2Position;
                msg.arg2 = outcome;
                messageHandler.sendMessage(msg);
                if (outcome == SUCCESS) {
                    gopherFound = true;
                    winner = "Player 2";
                    result.setText("Player 2 wins");
                    break;
                }
            }
            try {
                int sleep = r.nextInt(threadHigh - threadLow) + threadLow;
                Thread.sleep(sleep);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
            }
        }
    }
}

标签： javaandroidmultithreading

解决方案

以确保一个动作会一个接一个地触发。您可以简单地使用ThreadPoolExecutor. 像下一个。

final ThreadPoolExecutor executor = 
  (ThreadPoolExecutor) Executors.newFixedThreadPool(1);

executor.submit(new Runnable() {
     @Override 
     public void run() { 
           // Your action 1
     }
});

executor.submit(new Runnable() {
     @Override 
     public void run() { 
           // Your action 2
     }
})

推荐阅读