Java 使用两个线程和一个共享变量进行广播和应答

基本上，我试图用一个线程每秒发送一条广播消息，然后用另一个线程等待答复。问题是我似乎无法正确编写代码，所以我做了一个小示例，可以做同样的事情，运行两个线程，一个线程在另一个线程修改某个变量时停止。这是：

public class test {
    public static void main(String[] args){     
        test2 t = new test2();          
    }
}

public class test2 {
    private volatile Opponent b = new Opponent();

    public test2(){

        new Thread(new Runnable(){
            public void run(){  
            synchronized(this){
                while(!b.a){
                for(int i = 0; i < 100; i ++){
                    System.out.println(i);

                    try{
                        this.wait(1000);
                    }catch(InterruptedException ie){
                    }

                }
                }
            }
        }
    }).start();
    new Thread(new Runnable(){
        public void run(){  
            synchronized(this){
                for(int i = 0; i < 100; i ++){
                    System.out.println(i*100);

                    if(i*100 == 200){
                        b.a = true;
                        System.out.println("true");
                        }

                    try{
                        this.wait(1000);
                    }catch(InterruptedException ie){
                    }

                }

            }
        }
    }).start();
}
}
public class Opponent {

    static boolean a = false;

    public Opponent(){
    }
}

公共类测试{
公共静态void main（字符串[]args）{
test2t=新的test2（）；
}
}
公共类test2{
私人易变对手b=新对手（）；
公共测试2（）{
新线程（newrunnable（））{
public void run（）{
已同步（此）{
而（！b.a）{
对于（int i=0；i<100；i++）{
系统输出打印LN（i）；
试一试{
这个。等等（1000）；
}捕获（中断异常ie）{
}
}
}
}
}
}).start（）；
新线程（newrunnable（））{
public void run（）{
已同步（此）{
对于（int i=0；i<100；i++）{
系统输出打印项次（i*100）；
如果（i*100==200）{
b、 a=真；
System.out.println（“真”）；
}
试一试{
这个。等等（1000）；
}捕获（中断异常ie）{
}
}
}
}
}).start（）；
}
}
公众阶级对手{
静态布尔值a=false；
公众反对者（）{
}
}

我的问题是，如果我进行了同步（这个），线程将运行，但b.a永远不会更新，循环将永远继续。如果我进行了同步（b），我会得到一个非法的monitoreException

我做错了什么

---

谢谢

字段

对手。a

必须是

易变的

，因为它是正在修改的变量。在发布的代码中，

volatile

适用于

test2.b

，并且仅当新的

对手

实例被分配到

test2.b

时才有用。

test2.b

上的

volatile

无效，可以用

final

替换，因为它不会改变

请注意，作为

对手。a

是

静态的

对手的实例实际上不需要构造

示例更正：

// First thread loop condition.
//
while(!Opponent.a) {

// Second thread assignment.
//
Opponent.a = true;

public class Opponent
{   
    static volatile boolean a = false;
}

---

我试过了，但循环仍然永远运行。我应该在上做什么？如果我不同步，我会得到一个非法的MonitorStateException