java等待并通知

Question

我正在使用一个整数变量并与两个线程共享。一个线程应该打印偶数，一个线程应该顺序打印奇数。 但是 notify() 会抛出 IllegalMonitorStateException。

package mywaitnotifytest;
public class App {

    public static void main(String[] args) {
        Integer i=0;
        Even even = new Even(i);
        even.setName("EvenThread");
        Odd odd = new Odd(i);
        odd.setName("OddThread");
        even.start();
        odd.start();
    }
}

class Even extends Thread{

    Integer var;

    Even(Integer var){
        this.var=var;
    }

    @Override
    public void run() {
        while(true){
            synchronized (var) {
                if(var%2==0){
                    try {
                        var.wait();
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
                var++;
                System.out.println(Thread.currentThread().getName()+"  "+var);
                var.notify();
            }
        }

    }
}

class Odd extends Thread{

    Integer var;

    Odd(Integer var){
        this.var=var;
    }

    @Override
    public void run() {
        while(true){
            synchronized (var) {
                if(var%2!=0){
                    try {
                        var.wait();
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
                var++;
                System.out.println(Thread.currentThread().getName()+"  "+var);
                var.notify();
            }
        }
    }
}

输出是：

奇线程 1

Exception in thread "OddThread" java.lang.IllegalMonitorStateException

at java.lang.Object.notify(Native Method)

at mywaitnotifytest.Odd.run(App.java:67)

Answer 1

我认为这与通常的答案有很大不同，可以给出另一个答案。

在这种情况下，您使用的是synchronized。当您应用锁时，它是在对象而不是引用上。

---

synchronized (var) {

这会锁定对象var 引用，而不是锁定var 作为字段。

---

var++;

这将替换 var 指向的对象。是一样的

var = Integer.valueOf(var.intValue() + 1);

注意：Integer 实际上所有原始包装器都是不可变的。当您对它们执行任何操作时，您实际上是在拆箱，使用原始值进行计算并重新装箱对象。如果它被池化，则可以取回相同的对象。例如

Integer i = 10;
i += 0; // gives back the same object.

但是，如果对象没有被池化

Double d = 10;
d += 0; // creates a new object.

---

var.notify();

尝试在新对象上调用notify，而不是被锁定的对象。

---

您不应该尝试锁定您更改的字段。它不会做它看起来做的事情。您也不应该锁定池对象。在这种情况下，您可以让另一个线程使用相同的Integer 用于不相关的目的，而notify() 将唤醒一个不相关的线程。

要正确使用等待/通知，您应该

• notify() 或 notifyAll() 在另一个共享字段中的状态更改之后。
• 您应该对wait() 使用while 循环来检查状态变化。

如果你不这样做

• 如果没有其他线程等待，通知可能会丢失。
• wait 可能会虚假唤醒，即使没有调用 notify。

对于上述要求，代码中建议的编辑是什么？如何为多个线程共享同一个对象？

public class PingPong implements Runnable {    
    static class Shared { int num; }

    private final Shared var;
    private final int bit;

    public static void main(String[] args) {
        Shared var = new Shared();
        new Thread(new PingPong(var, 0), "EvenThread").start();
        new Thread(new PingPong(var, 1), "OddThread").start();
    }

    PingPong(Shared var, int bit) {
        this.var = var;
        this.bit = bit;
    }

    @Override
    public void run() {
        try {
            String name = Thread.currentThread().getName();
            while (true) {
                synchronized (var) {
                    while (var.num % 2 == bit)
                        var.wait();

                    var.num++;
                    System.out.println(name + "  " + var.num);
                    var.notify();
                }
            }
        } catch (InterruptedException e) {
            System.out.println("Interrupted");
        }
    }
}

Answer 2

我没有使用整数包装类，而是创建了自己的类，现在它可以正常工作了。

package mywaitnotifytest;

public class App {
    public static void main(String[] args) {
        MyInt i = new MyInt(0);
        Even even = new Even(i);
        even.setName("EvenThread");
        Odd odd = new Odd(i);
        odd.setName("OddThread");
        even.start();
        odd.start();
    }
}

class Even extends Thread {

    MyInt var;

    Even(MyInt var) {
        this.var = var;
    }

    @Override
    public void run() {
        while (true) {
            try {
                Thread.sleep(200);
            } catch (InterruptedException e1) {
                // TODO Auto-generated catch block
                e1.printStackTrace();
            }
            synchronized (var) {
                if (var.i % 2 == 0) {
                    try {
                        var.wait();
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
                var.i++;
                System.out.println(Thread.currentThread().getName() + "  " + var.i);
                var.notify();
            }
        }

    }

}

class Odd extends Thread {
    MyInt var;

    Odd(MyInt var) {
        this.var = var;
    }

    @Override
    public void run() {
        while (true) {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e1) {
                // TODO Auto-generated catch block
                e1.printStackTrace();
            }
            synchronized (var) {
                if (var.i % 2 != 0) {
                    try {
                        var.wait();
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
                var.i++;
                System.out.println(Thread.currentThread().getName() + "   " + var.i);
                var.notify();

            }
        }

    }
}

class MyInt {
    int i = 0;

    public MyInt(int i) {
        super();
        this.i = i;
    }

    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return "" + i;
    }

}