为什么线程通信在 java 中不起作用？

Question

我正在开发一个基于 java 的小型游戏，我正在尝试由玩家 1 发射导弹，直到玩家 1 没有错过目标，一旦玩家 1 错过了目标，燕鸥就会移动对 Player-2，Player-2 将开始射击，直到他错过目标，反之亦然。

这里Player-1和Player-2都是Java Runnable任务请看下面的代码:

public class GameRender implements IGame {
    private Game game;
    private Player player1, player2;
    private Lock lock = new ReentrantLock();
    Condition notPlayer1TernCondition = lock.newCondition();
    Condition notPlayer2TernCondition = lock.newCondition();

    public GameRender(Game game, Player player1, Player player2) {
        this.game = game;
        this.player1 = player1;
        this.player2 = player2;
    }

    @Override
    public void create() {

    }

    @Override
    public void render() {
        //ExecutorService executorService = Executors.newFixedThreadPool(2);
        Player1Task plater1 = new Player1Task(player1.getTargetLocations(), true);
        Player2Task plater2 = new Player2Task(player2.getTargetLocations(), false);

        Thread t1 = new Thread(plater1);
        Thread t2 = new Thread(plater2);

        t1.start();
        t2.start();
    }

    @Override
    public void over() {

    }


    class Player1Task implements Runnable {
        private List<TargetLocation> playerOnesTargetLocationList;
        private boolean isHitTarget = false;
        private int fireCount = 0;
        private boolean yourTern;

        Player1Task(List<TargetLocation> playerOnesTargetLocationList, boolean yourTern) {
            this.playerOnesTargetLocationList = playerOnesTargetLocationList;
            this.yourTern = yourTern;
        }

        @Override
        public void run() {
            try {
                lock.lock();
                fire();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }

        private void fire() throws InterruptedException {
            while (fireCount != playerOnesTargetLocationList.size()) {
                if (!yourTern) {
                    notPlayer1TernCondition.await();
                }
                TargetLocation location = playerOnesTargetLocationList.get(fireCount);
                if (player2.getOwnField().hasShip(location.getxPos(), location.getyPos())) {

                } else {
                    System.out.println("Player-1 else");
                    yourTern = false;
                    notPlayer2TernCondition.signalAll();
                }
                fireCount++;
            }

        }

    }

    class Player2Task implements Runnable {
        private List<TargetLocation> playerTwosTargetLocationList;
        private boolean isHitTarget = false;
        private int fireCount = 0;
        private boolean yourTern;

        Player2Task(List<TargetLocation> playerTwosTargetLocationList, boolean youTern) {
            this.playerTwosTargetLocationList = playerTwosTargetLocationList;
            this.yourTern = youTern;
        }

        @Override
        public void run() {
            lock.lock();
            try {
                fire();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }

        private void fire() throws InterruptedException {

            while (fireCount != playerTwosTargetLocationList.size()) {
                if (!yourTern) {
                    notPlayer2TernCondition.await();
                }

                TargetLocation location = playerTwosTargetLocationList.get(fireCount);
                if (player1.getOwnField().hasShip(location.getxPos(), location.getyPos())) {

                } else {
                    System.out.println("p2 else");
                    yourTern = false;
                    notPlayer1TernCondition.signalAll();
                }
                fireCount++;
            }

        }
    }
}

以上代码未按预期运行，Player-1 第一次执行后代码卡住了。

非常感谢任何解释。

Answer 1

您永远不会将您的 Tern 设置回 true。（可以改用表示轮到哪个玩家的共享变量）

说明：假设最初 Player1 拥有锁并开火，因为 Player1 的 yourTern 为真。假设它 未命中 那么你将向 Player2（ 尚未等待 ）发出信号并将你的 Tern 设置为 false 并释放锁（通过调用 notPlayer1TernCondition.await() 方法在下一次迭代中）。
这个锁将被 Player2 获取并且它会调用 notPlayer2TernCondition.await() 因为它的 yourTern 是假的。
两个线程现在将永远进入等待状态。

为什么线程通信在 java 中不起作用？

Why Thread communication is not working in java?

java

multithreading

java.util.concurrent