java如何实现等待

在Java中实现等待的方式主要有以下四种：1、使用Thread的sleep()方法；2、使用Object的wait()方法；3、使用Lock和Condition的await()方法；4、使用Future的get()方法。

首先，我们来详细探讨第一种方式：使用Thread的sleep()方法。

一、使用THREAD的SLEEP()方法

Thread类中的sleep()方法可以使当前线程处于暂停状态，也就是等待状态，其参数是要暂停的毫秒数。当暂停的时间到达后，线程会自动恢复运行。这种方式的等待是被动的，也就是说，线程在等待期间无法做其他事情。

public class SleepDemo {
    public static void main(String[] args) {
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                System.out.println(i);
                try {
                    Thread.sleep(1000); // 每次输出后暂停1秒
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }
}

在这个示例中，我们创建了一个新的线程，这个线程会输出0到9这10个数字，每次输出后会暂停1秒。这就是通过Thread的sleep()方法实现等待的一个基本示例。

二、使用OBJECT的WAIT()方法

Object类中的wait()方法也可以使当前线程进入等待状态，但与Thread的sleep()方法不同的是，wait()方法需要在同步代码块或同步方法中使用，而且它可以被其他线程通过notify()或notifyAll()方法唤醒。

public class WaitNotifyDemo {
    public static void main(String[] args) {
        Object lock = new Object();
        new Thread(() -> {
            synchronized (lock) {
                System.out.println("Waiting...");
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Notified");
            }
        }).start();
        new Thread(() -> {
            try {
                Thread.sleep(2000); // 等待2秒以便第一个线程有足够的时间进入等待状态
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (lock) {
                lock.notify(); // 唤醒在lock对象上等待的线程
            }
        }).start();
    }
}

这个示例中，我们创建了两个线程，第一个线程会在lock对象上等待，第二个线程会在2秒后唤醒在lock对象上等待的线程。

三、使用LOCK和CONDITION的AWAIT()方法

Lock接口中定义了一个newCondition()方法，这个方法会返回一个Condition对象，我们可以通过这个对象的await()方法使线程进入等待状态，然后通过其signal()方法唤醒等待的线程。

public class AwaitSignalDemo {
    public static void main(String[] args) {
        Lock lock = new ReentrantLock();
        Condition condition = lock.newCondition();
        new Thread(() -> {
            lock.lock();
            try {
                System.out.println("Waiting...");
                condition.await();
                System.out.println("Notified");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }).start();
        new Thread(() -> {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            lock.lock();
            try {
                condition.signal();
            } finally {
                lock.unlock();
            }
        }).start();
    }
}

这个示例同样创建了两个线程，第一个线程会在condition条件上等待，第二个线程会在2秒后唤醒在condition条件上等待的线程。

四、使用FUTURE的GET()方法

Future接口中定义了一个get()方法，这个方法会阻塞当前线程，直到Future对象代表的异步任务完成。因此，我们可以通过调用Future的get()方法实现等待。

public class FutureDemo {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        Future<String> future = executor.submit(() -> {
            Thread.sleep(2000); // 模拟异步任务
            return "Hello, World!";
        });
        System.out.println("Waiting for result...");
        try {
            String result = future.get(); // 等待异步任务完成并获取结果
            System.out.println("Result: " + result);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
        executor.shutdown();
    }
}

这个示例中，我们创建了一个异步任务，这个任务会在2秒后返回一个字符串。然后我们通过Future的get()方法等待这个异步任务完成并获取其结果。

以上就是在Java中实现等待的四种主要方式。

java如何实现等待

相关问答FAQs：