为什么使用类锁在多线程编程中会导致错误？

线程间通信：使用对象锁与类锁的对比

在多线程编程中，线程间通信是一个至关重要的概念。一个常见的机制是使用对象锁，而另一个选项是使用类锁。

在提供的问题示例中，printer_1类使用对象锁实现了线程通信。在这个示例中，线程安全地打印从 1 到 100 的数字。代码如下所示：

public class threadtalk {
    public static void main(string[] args) {
        printer_1 printer = new printer_1();
        thread t1 = new thread(printer);
        thread t2 = new thread(printer);
        t1.setname("线程一");
        t2.setname("线程二");
        t1.start();
        t2.start();
    }
}

class printer_1 implements runnable {
    private int number = 0;

    @override
    public void run() {
        while (true) {
            synchronized (printer_1.class) {
                notify();
                if (number <= 100) {
                    system.out.println(thread.currentthread().getname() + "打印数字：" + number);
                    number++;
                    try {
                        wait();
                    } catch (interruptedexception e) {
                        e.printstacktrace();
                    }
                } else {
                    break;
                }
            }
        }
    }
}

在这种情况下，使用对象锁是正确的做法，因为它确保了每个线程只访问自己的打印机实例。

为什么使用类锁会报错？

然而，问题示例中指出，使用类锁会导致错误。原因如下：

LongCat AI

美团推出的AI对话问答工具

下载

当使用 synchronized (printer_1.class) 时，类锁被持有。但是，在 run() 方法内部，线程却在使用 notify() 和 wait() 方法，这两个方法只能在持有对象锁时使用。在使用类锁时，持有的是类的锁，而不是对象锁。因此，当一个线程调用 wait() 时，类锁会被释放，而当另一个线程试图调用 notify() 时，就会抛出 illegalmonitorstateexception 错误。

解决方案

要解决这个问题，您应该在使用 wait() 和 notify() 方法时持有对象锁。在给出的示例中，正确的做法是：

synchronized (this) {
    ... your code ...
}

或者，也可以使用静态方法：

synchronized (Printer_1.class) {
    Printer_1.class.wait();
    Printer_1.class.notify();
}