Java并发编程：wait()方法与监视器锁的正确关联

public class Server {
    private boolean sicherungswunsch = false;
    private int anzahlClients = 0;
    private final int maxClients = 5;

    // 假设Client是一个简单的POJO类，包含一个ID
    static class Client {
        int ID;
        public Client(int id) { this.ID = id; }
    }

    public synchronized void daten_ablegen(Client c) throws InterruptedException {
        System.out.println("Client " + c.ID + " will Daten ablegen");

        // 当条件不满足时，客户端线程进入等待状态
        while (sicherungswunsch || (anzahlClients >= maxClients)) {
            System.out.println("Client " + c.ID + " sleeps.");
            // 错误：在此处调用了客户端对象c的wait()方法
            c.wait(); 
        }

        anzahlClients++;
        System.out.println("当前有 " + anzahlClients + " Clients 正在处理数据。");
        // ... 执行数据存储逻辑 ...
    }

    public static void main(String[] args) {
        Server server = new Server();
        // 模拟多个客户端并发调用daten_ablegen
        for (int i = 0; i < 3; i++) {
            final int clientId = i;
            new Thread(() -> {
                try {
                    server.daten_ablegen(new Client(clientId));
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    System.err.println("Client " + clientId + " interrupted.");
                }
            }).start();
        }
    }
}

public class Server {
    private boolean sicherungswunsch = false;
    private int anzahlClients = 0;
    private final int maxClients = 2; // 调整maxClients以便更容易触发等待

    static class Client {
        int ID;
        public Client(int id) { this.ID = id; }
    }

    public synchronized void daten_ablegen(Client c) throws InterruptedException {
        System.out.println("Client " + c.ID + " will Daten ablegen");

        // 线程必须持有调用wait()方法的对象的监视器锁。
        // 在此方法中，synchronized关键字锁定的是当前对象实例（即this）。
        // 因此，wait()方法也必须在当前对象实例上调用。
        while (sicherungswunsch || (anzahlClients >= maxClients)) {
            System.out.println("Client " + c.ID + " sleeps, waiting for Server resources.");
            this.wait(); // 正确：在当前Server对象上调用wait()
            // 或者直接 wait(); 因为在非静态方法中，wait() 默认就是 this.wait()
        }

        anzahlClients++;
        System.out.println("Client " + c.ID + " 开始处理。当前有 " + anzahlClients + " Clients 正在处理数据。");

        // 模拟数据处理
        Thread.sleep(1000); 

        anzahlClients--;
        System.out.println("Client " + c.ID + " 处理完成。剩余 " + anzahlClients + " Clients 正在处理数据。");
        // 处理完成后，唤醒其他等待的线程
        this.notifyAll(); // 唤醒所有等待Server锁的线程
    }

    // 模拟一个方法来改变sicherungswunsch或maxClients，从而唤醒等待线程
    public synchronized void releaseResources() {
        System.out.println("Server释放资源，通知等待中的客户端。");
        this.sicherungswunsch = false;
        this.notifyAll(); // 唤醒所有等待Server锁的线程
    }

    public static void main(String[] args) {
        Server server = new Server();
        // 模拟多个客户端并发调用daten_ablegen
        for (int i = 0; i < 5; i++) {
            final int clientId = i;
            new Thread(() -> {
                try {
                    server.daten_ablegen(new Client(clientId));
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    System.err.println("Client " + clientId + " interrupted.");
                }
            }, "Client-Thread-" + clientId).start();
        }

        // 模拟一段时间后释放资源
        try {
            Thread.sleep(5000); 
            server.releaseResources();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}