在Java编程中，等待与回调机制是提高代码效率与可读性的重要手段。通过合理运用这两种机制，我们可以使代码更加高效、简洁，同时降低耦合度。本文将详细介绍Java中的等待与回调机制，并提供实际案例供读者参考。

等待机制

等待机制主要是指通过多线程实现的一种同步机制。在Java中，我们可以使用wait()、notify()和notifyAll()方法来实现等待与通知。

wait()方法

wait()方法是Object类中的一个方法，它使得当前线程暂停执行，直到另一个线程调用该对象的notify()或notifyAll()方法。使用wait()方法时，需要将其放在synchronized块或方法中。

synchronized (object) {
    object.wait();
}

notify()和notifyAll()方法

notify()方法唤醒一个正在等待该对象监视器的线程。如果有多个线程正在等待，则随机选择一个线程唤醒。而notifyAll()方法则唤醒所有等待该对象监视器的线程。

synchronized (object) {
    object.notify();
    // 或者
    object.notifyAll();
}

实际案例

以下是一个使用等待机制实现生产者-消费者模式的示例：

class Producer implements Runnable {
    private final Object lock;

    public Producer(Object lock) {
        this.lock = lock;
    }

    @Override
    public void run() {
        try {
            synchronized (lock) {
                // 生产数据
                System.out.println("生产者生产数据...");
                lock.notify();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

class Consumer implements Runnable {
    private final Object lock;

    public Consumer(Object lock) {
        this.lock = lock;
    }

    @Override
    public void run() {
        try {
            synchronized (lock) {
                lock.wait();
                // 消费数据
                System.out.println("消费者消费数据...");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

回调机制

回调机制是指在某个任务执行完成后，自动执行另一个任务。在Java中，我们可以通过接口和匿名内部类来实现回调。

接口回调

接口回调是指通过实现一个接口来定义回调方法。以下是一个使用接口回调实现异步任务的示例：

interface Callback {
    void onTaskComplete();
}

class AsyncTask implements Runnable {
    private final Callback callback;

    public AsyncTask(Callback callback) {
        this.callback = callback;
    }

    @Override
    public void run() {
        // 执行异步任务
        System.out.println("异步任务执行中...");

        // 任务完成后，执行回调
        callback.onTaskComplete();
    }
}

class Main {
    public static void main(String[] args) {
        Callback callback = new Callback() {
            @Override
            public void onTaskComplete() {
                System.out.println("异步任务完成！");
            }
        };

        AsyncTask asyncTask = new AsyncTask(callback);
        new Thread(asyncTask).start();
    }
}

匿名内部类回调

匿名内部类回调是指在回调方法中直接创建一个匿名内部类来实现回调。以下是一个使用匿名内部类回调实现异步任务的示例：

class AsyncTask implements Runnable {
    @Override
    public void run() {
        // 执行异步任务
        System.out.println("异步任务执行中...");

        // 任务完成后，执行回调
        new Runnable() {
            @Override
            public void run() {
                System.out.println("异步任务完成！");
            }
        }.run();
    }
}

class Main {
    public static void main(String[] args) {
        AsyncTask asyncTask = new AsyncTask();
        new Thread(asyncTask).start();
    }
}

总结

本文介绍了Java中的等待与回调机制，并通过实际案例展示了如何使用这两种机制提高代码效率与可读性。在实际开发中，合理运用等待与回调机制可以使代码更加简洁、高效，降低耦合度。希望本文能对您有所帮助。