java - 同步两个互不相识的线程[Java]

Question

首先，请原谅我糟糕的英语 =S 其次，抱歉，如果我的标题有点奇怪，我不知道如何更好地表达它。

我有个小问题。我正在用 Java 开发一个游戏，我正在按照教给我的方式使用 MVC 模式。我不知道这是否是最有效的方法，但无论如何，这是总体情况:4 个包:模型、 View 、 Controller 和“观察者”。

在观察者中，有一个“观察者”接口(interface)，其中定义了一个“观察模型”的元素应该实现的所有方法。还有一个“Observable”类，它有一个观察者列表，以及所有通知他们一些变化的方法(像“fireEvent1(int i) { for (Observer obs: observers) obs.Event1(i); }”这样的方法) )该模型扩展了 Observable 类，GUI 的一些元素实现了 Observer 接口(interface)。

现在我的问题是:在模型的一个方法中，我希望模型“等待”2 次用户交互。这意味着类似的东西:

• 模型中调用的方法
• 做一些事情
• 等待用户第一次互动
• 获取有关用户刚刚做了什么的信息(收集在 Controller 中)
• 做一些事情
• 等待用户第二次互动
• 获取信息
• 做事
• 结束

一个精度:用户的交互被收集在实现ActionListener的 Controller 中， View 的元素将 Controller 作为ActionListener。

所以我想我必须使用线程，但尽管我找到了所有教程和示例，但我仍然无法完成这项工作。我试图在模型中启动一个线程，让它等待，但我无法在 Controller 中创建另一个线程，与第一个线程同步并在必要时通知它。我什至不知道这样做是否正确，无论如何，我已经在这个问题上研究了几个小时，我只是不知道如何解决它。

我希望我的解释很清楚，如果没有，请随时提问，然后我会尝试编写一个简单的代码来代表我的问题。

谢谢你的帮助

Scentle5S

编辑:这是代表我的问题的一小段代码。所以我希望模型能够从 View 中获取信息，一个接一个，只有两次。我在模型中启动一个线程并让它等待(顺便说一下，我多次看到无限循环让线程等待，但我不明白为什么有必要。简单调用 wait() 不是吗，没有循环，也能完成这项工作吗？)。

但很明显，这里没有其他线程与模型同步，能够在执行操作时通知并传输数据。

我不知道该怎么做。

public class Model extends Observable {

    public void waitForActions() {
        System.out.println("Wating for two user's actions");

        Thread t = new Thread() {
            public void run() {
                while (true) {
                    try {
                        wait();
                    } catch (InterruptedException e) {
                    }
                }
                System.out.println("First action received in model : "
                        + message);
                while (true) {
                    try {
                        wait();
                    } catch (InterruptedException e) {
                    }
                }
                System.out.println("Second action received in model : "
                        + message);
            }
        };
        fireWaitForActions(true);
        t.start();
        fireWaitForActions(false);
    }
}

public class Controler implements ActionListener {
    private Model model;

    public Controler(Model model) {
        this.model = model;
    }

    public void actionPerformed(ActionEvent e) {
        String message = ((JButton)e.getSource()).getText();
        System.out.println("Action received in controler : "+message);
    }
}

public class View extends JFrame implements Observer {
    private JButton b1 = new JButton("Action 1");
    private JButton b2 = new JButton("Action 2");
    private Controler controler;

    public View(Controler controler) {
        this.controler = controler;

        b1.addActionListener(controler);
        b2.addActionListener(controler);

        b1.setEnabled(false);
        b2.setEnabled(false);

        JPanel container = new JPanel();
        container.add(b1);
        container.add(b2);
        setContentPane(container);
        pack();
        setLocationRelativeTo(null);
        setVisible(true);
    }

    public void waitForActions(Boolean b) {
        b1.setEnabled(b);
        b2.setEnabled(b);       
    }
}

public static void main(String[] args) {
    Model model = new Model();
    Controler controler = new Controler(model);
    View view = new View(controler);
    model.addObserver(view);
    model.waitForActions();
}

这是 Observable 和 Observer 类/接口(interface):

public class Observable {
    private LinkedList<Observer> observers = new LinkedList<Observer>();

    public void addObserver(Observer obs) {
        observers.add(obs);
    }

    public void fireWaitForActions(boolean b) {
        for (Observer obs: observers) obs.waitForActions(b);
    }
}

public interface Observer {
    public void waitForActions(Boolean b);
}

Answer 1

有很多方法可以做到这一点。在您的 Java 语言手册中查找线程同步方法。

您可以在两个线程都可以看到的对象上使用 wait() 和 notify()。您可以在两个线程都可以看到的信号量上使用 acquire() 和 release()。您或许可以使用阻塞队列构建解决方案。

wait()/notify() 或 acquire()/release() 可能是最简单的。