线程同步问题及思考

今天在复习初级线程同步的机制。题目是两个线程同时取钱，每次取1000，初始余额为20000.不得超取。我的代码如下：

package review20240730;

public class Homework02 {
    public static void main(String[] args) {
        User user = new User();
        User user1 = new User();
        new Thread(user).start();
        new Thread(user1).start();
    }
}


class User implements Runnable {
    private static int balance = 30000;

    private int takeMoney = 1000;

    @Override
    public void run() {
        while (true) {
            synchronized (this) {
                if (balance < 1000) {
                    System.out.println("取钱结束");
                    return;
                }
                withdraw();
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

    }

    public void withdraw() {
        balance -= takeMoney;
        System.out.println(Thread.currentThread().getName() + ",还剩" + balance);
    }

}

无论我的synchronized放在while循环中，还是放在withdraw()方法，都不能实现线程同步。

原因如下：

在User类中，synchronized块被锁定在this对象上。然而，在main方法中，创建了两个不同的User对象（user和user1），并且分别为它们启动了线程。由于每个User对象都是独立的实例，因此synchronized(this)实际上是在每个User实例上分别加锁，而不是在balance这个共享资源上。

这意味着，虽然每个User实例内部的withdraw方法调用是线程安全的（因为它防止了同一实例的多个线程同时执行withdraw），但两个不同User实例之间的线程并不受这个锁的影响。因此，两个线程可能会同时进入各自的withdraw方法，从而导致balance的值被错误地减少。

要解决这个问题，应该将锁放在一个共享的、所有User实例都可以访问的对象上，或者更简单地，由于balance是静态的，你可以直接在balance上加锁。但是，由于balance是一个静态变量，并且想要在多个线程之间同步对它的访问，可以通过同步一个静态的锁对象来实现。这个锁对象可以是一个专用的静态Object实例，或者你可以使用类的Class对象本身作为锁。使用类的Class对象作为锁是一种常见且简单的方法，特别是当锁保护的是静态变量时。

实践方案：

（1）专用的静态Object实例：

​ 在User类中加入Object的lock对象，private static final Object lock = new Object();

synchronized改为 synchronized (lock){…},即可实现同步

（2） 使用类的Class对象本身作为锁:

synchronized (User.class) {…}

完美解决！