Java 如何序列化正在同步的代码？

我需要创建两个类，

classplayer

和

classreference

，它们

实现Runnable

接口（基本上是创建线程）

线程必须执行的顺序如下

裁判 玩家1或玩家2 裁判 玩家1或玩家2 等等

这里，是我提出的解决方案，但是，顺序似乎没有发生。甚至在裁判员完成检查之前，球员们仍在继续比赛

``

我知道不同对象的线程不能同步，序列化同步中的代码没有意义。这是分配给我的任务。在上面的代码中，玩家即使在提供了一组条件变量之后也会同时比赛，并且不允许裁判线程在每次比赛时检查胜利者

---

请给我一个使用synchronized方法notify（）和wait（）提供这种输出的代码大纲。

这是允许的，但很少有意义，在您的情况下也没有意义。这两个线程将在不同的对象上同步，这不会产生任何效果。同步方法的要点是防止两个线程同时访问同一个对象。如果两个玩家需要访问某个公共对象，但您不希望访问重叠，则应在该对象上同步，或同步该对象的一个方法。您应该在同步块或方法中停留尽可能短的时间。不必要的同步可能导致性能差或死锁

对我来说最有意义的是：

a

public static class a {

    static boolean finish = false;

    public static void main(String[] args) throws InterruptedException {

        finish = false;

        ExecutorService executorService = Executors.newCachedThreadPool();

        executorService.execute(new Referee());
        executorService.execute(new Player(1));
        executorService.execute(new Player(2));

        // wait for user to press enter, just for testing
        new Scanner(System.in).nextLine();
        executorService.shutdown();
        executorService.awaitTermination(1, TimeUnit.MINUTES);
    }
}

玩家

public class Player implements Runnable {

    final int playernum;

    public Player(int playernum) {
        this.playernum = playernum;
    }

    @Override
    public void run() {
        try {
            while (!a.finish) {

                synchronized (a.class) {
                    for (int i = 0; i < 5; i++) {
                        Thread.sleep(1000);
                        System.out.println("player " + playernum + " does step " + i);
                    }
                }
                Thread.sleep(1000);
            }
        } catch (InterruptedException interruptedException) {
        }
    }
}

请注意，它在整个运行期间不同步，仅在内部块期间同步

它应该产生这样的结果：

Check for winner.
player 1 does step 0
player 1 does step 1
player 1 does step 2
player 1 does step 3
player 1 does step 4
Check for winner.
player 2 does step 0
player 2 does step 1
player 2 does step 2
player 2 does step 3
player 2 does step 4

---

如果没有同步，您将无法看到每个玩家的所有5步，而没有其他玩家的干预检查或步骤

synchronized run（）

应该可以正常工作。但是，请注意，这仅在

Runnable

实例上提供互斥，而不在实例之间提供互斥；只有同时多次运行同一个

Runnable

实例，才能获得锁定。您错了。这是允许的。这也是毫无意义的。我是唯一一个认为这是一个糟糕的设计开始吗？球员和裁判员应该是常规对象。并行运行不是他们的责任！你应该创建一个“GameEngine”类，它将跨越线程，这些线程应该对玩家和裁判做一些有用的事情。@DavidHaim，我也这么认为。但是，这是我正在完成的任务的一个要求。到目前为止，我并不担心表现。我需要使用类似的结构编写代码。你能帮我一下吗？不幸的是，我不能从给定的代码中判断是否需要同步任何内容。当前代码是否符合您的要求？如果不是，你到底想要什么，这与运行时的结果有什么不同。我们需要putReady和getReady函数的代码。它们是静态的吗？ready的初始值是多少？wait（）和notify（）也作用于不同的对象，因此它们不会通信。是的，putReady和getReady函数是静态的，它们仅用于检索或更改ready变量的值。实现游戏的代码运行良好。我需要球员像任何比赛一样，与裁判一起连续比赛。但是，有时两名球员同时比赛而不允许裁判检查胜利者。这就是我所需要做的。ready变量的初始值为false。所以，当ready变量的值为false时，裁判检查是否有赢家。检查赢家后，如果没有赢家，它会将ready变量的值更改为true。同时，当ready变量的值为false时，玩家等待。当（getReady（））wait（）时，

中提到了这种情况。当裁判员将ready变量的值更改为true时，不是只有一名球员能够获得锁定，而是两名球员同时比赛。我需要两个玩家中的任何一个立即玩这个游戏。添加了示例代码来回答。
public class Referee implements Runnable {

    @Override
    public void run() {
        try {
            while (!a.finish) {
                synchronized (a.class) {
                    System.out.println("Check for winner.");
                }
                Thread.sleep(1000);
            }
        } catch (InterruptedException interruptedException) {
        }
    }
}

Check for winner.
player 1 does step 0
player 1 does step 1
player 1 does step 2
player 1 does step 3
player 1 does step 4
Check for winner.
player 2 does step 0
player 2 does step 1
player 2 does step 2
player 2 does step 3
player 2 does step 4